{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31mFailed to start the Kernel. \n",
      "\u001b[1;31mThe kernel died. Error: ... View Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
     ]
    }
   ],
   "source": [
    "import warnings\n",
    "from torch import multiprocessing\n",
    "from collections import defaultdict\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "from tensordict.nn import TensorDictModule\n",
    "from tensordict.nn.distributions import NormalParamExtractor\n",
    "from torch import nn\n",
    "from torchrl.collectors import SyncDataCollector\n",
    "from torchrl.data.replay_buffers import ReplayBuffer\n",
    "from torchrl.data.replay_buffers.samplers import SamplerWithoutReplacement\n",
    "from torchrl.data.replay_buffers.storages import LazyTensorStorage\n",
    "from torchrl.envs import (\n",
    "    Compose,\n",
    "    DoubleToFloat,\n",
    "    ObservationNorm,\n",
    "    StepCounter,\n",
    "    TransformedEnv,\n",
    ")\n",
    "from torchrl.envs.libs.gym import GymEnv\n",
    "from torchrl.envs.utils import check_env_specs, ExplorationType, set_exploration_type\n",
    "from torchrl.modules import ProbabilisticActor, TanhNormal, ValueOperator\n",
    "from torchrl.objectives import ClipPPOLoss\n",
    "from torchrl.objectives.value import GAE\n",
    "from tqdm import tqdm\n",
    "import time\n",
    "import numpy as np\n",
    "import cv2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "warnings.filterwarnings(\"ignore\")\n",
    "is_fork = multiprocessing.get_start_method() == \"fork\"\n",
    "device = (\n",
    "    torch.device(0)\n",
    "    if torch.cuda.is_available() and not is_fork\n",
    "    else torch.device(\"cpu\")\n",
    ")\n",
    "num_cells = 512\n",
    "lr = 1e-4\n",
    "max_grad_norm = 0.2\n",
    "frames_per_batch = 2048\n",
    "total_frames = 5_000_000\n",
    "sub_batch_size = 1024\n",
    "num_epochs = 10\n",
    "clip_epsilon = 0.2\n",
    "gamma = 0.99\n",
    "lmbda = 0.95\n",
    "entropy_eps = 1e-3\n",
    "save_path = \"./ppo_record/\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "normalization constant shape: torch.Size([376])\n",
      "observation_spec: Composite(\n",
      "    observation: UnboundedContinuous(\n",
      "        shape=torch.Size([376]),\n",
      "        space=ContinuousBox(\n",
      "            low=Tensor(shape=torch.Size([376]), device=cuda:0, dtype=torch.float32, contiguous=True),\n",
      "            high=Tensor(shape=torch.Size([376]), device=cuda:0, dtype=torch.float32, contiguous=True)),\n",
      "        device=cuda:0,\n",
      "        dtype=torch.float32,\n",
      "        domain=continuous),\n",
      "    pixels: UnboundedDiscrete(\n",
      "        shape=torch.Size([480, 480, 3]),\n",
      "        space=ContinuousBox(\n",
      "            low=Tensor(shape=torch.Size([480, 480, 3]), device=cuda:0, dtype=torch.uint8, contiguous=True),\n",
      "            high=Tensor(shape=torch.Size([480, 480, 3]), device=cuda:0, dtype=torch.uint8, contiguous=True)),\n",
      "        device=cuda:0,\n",
      "        dtype=torch.uint8,\n",
      "        domain=discrete),\n",
      "    step_count: BoundedDiscrete(\n",
      "        shape=torch.Size([1]),\n",
      "        space=ContinuousBox(\n",
      "            low=Tensor(shape=torch.Size([1]), device=cuda:0, dtype=torch.int64, contiguous=True),\n",
      "            high=Tensor(shape=torch.Size([1]), device=cuda:0, dtype=torch.int64, contiguous=True)),\n",
      "        device=cuda:0,\n",
      "        dtype=torch.int64,\n",
      "        domain=discrete),\n",
      "    device=cuda:0,\n",
      "    shape=torch.Size([]))\n",
      "reward_spec: UnboundedContinuous(\n",
      "    shape=torch.Size([1]),\n",
      "    space=ContinuousBox(\n",
      "        low=Tensor(shape=torch.Size([1]), device=cuda:0, dtype=torch.float32, contiguous=True),\n",
      "        high=Tensor(shape=torch.Size([1]), device=cuda:0, dtype=torch.float32, contiguous=True)),\n",
      "    device=cuda:0,\n",
      "    dtype=torch.float32,\n",
      "    domain=continuous)\n",
      "input_spec: Composite(\n",
      "    full_state_spec: Composite(\n",
      "        step_count: BoundedDiscrete(\n",
      "            shape=torch.Size([1]),\n",
      "            space=ContinuousBox(\n",
      "                low=Tensor(shape=torch.Size([1]), device=cuda:0, dtype=torch.int64, contiguous=True),\n",
      "                high=Tensor(shape=torch.Size([1]), device=cuda:0, dtype=torch.int64, contiguous=True)),\n",
      "            device=cuda:0,\n",
      "            dtype=torch.int64,\n",
      "            domain=discrete),\n",
      "        device=cuda:0,\n",
      "        shape=torch.Size([])),\n",
      "    full_action_spec: Composite(\n",
      "        action: BoundedContinuous(\n",
      "            shape=torch.Size([17]),\n",
      "            space=ContinuousBox(\n",
      "                low=Tensor(shape=torch.Size([17]), device=cuda:0, dtype=torch.float32, contiguous=True),\n",
      "                high=Tensor(shape=torch.Size([17]), device=cuda:0, dtype=torch.float32, contiguous=True)),\n",
      "            device=cuda:0,\n",
      "            dtype=torch.float32,\n",
      "            domain=continuous),\n",
      "        device=cuda:0,\n",
      "        shape=torch.Size([])),\n",
      "    device=cuda:0,\n",
      "    shape=torch.Size([]))\n",
      "action_spec (as defined by input_spec): BoundedContinuous(\n",
      "    shape=torch.Size([17]),\n",
      "    space=ContinuousBox(\n",
      "        low=Tensor(shape=torch.Size([17]), device=cuda:0, dtype=torch.float32, contiguous=True),\n",
      "        high=Tensor(shape=torch.Size([17]), device=cuda:0, dtype=torch.float32, contiguous=True)),\n",
      "    device=cuda:0,\n",
      "    dtype=torch.float32,\n",
      "    domain=continuous)\n",
      "rollout of three steps: TensorDict(\n",
      "    fields={\n",
      "        action: Tensor(shape=torch.Size([3, 17]), device=cuda:0, dtype=torch.float32, is_shared=True),\n",
      "        done: Tensor(shape=torch.Size([3, 1]), device=cuda:0, dtype=torch.bool, is_shared=True),\n",
      "        next: TensorDict(\n",
      "            fields={\n",
      "                done: Tensor(shape=torch.Size([3, 1]), device=cuda:0, dtype=torch.bool, is_shared=True),\n",
      "                observation: Tensor(shape=torch.Size([3, 376]), device=cuda:0, dtype=torch.float32, is_shared=True),\n",
      "                pixels: Tensor(shape=torch.Size([3, 480, 480, 3]), device=cuda:0, dtype=torch.uint8, is_shared=True),\n",
      "                reward: Tensor(shape=torch.Size([3, 1]), device=cuda:0, dtype=torch.float32, is_shared=True),\n",
      "                step_count: Tensor(shape=torch.Size([3, 1]), device=cuda:0, dtype=torch.int64, is_shared=True),\n",
      "                terminated: Tensor(shape=torch.Size([3, 1]), device=cuda:0, dtype=torch.bool, is_shared=True),\n",
      "                truncated: Tensor(shape=torch.Size([3, 1]), device=cuda:0, dtype=torch.bool, is_shared=True)},\n",
      "            batch_size=torch.Size([3]),\n",
      "            device=cuda:0,\n",
      "            is_shared=True),\n",
      "        observation: Tensor(shape=torch.Size([3, 376]), device=cuda:0, dtype=torch.float32, is_shared=True),\n",
      "        pixels: Tensor(shape=torch.Size([3, 480, 480, 3]), device=cuda:0, dtype=torch.uint8, is_shared=True),\n",
      "        step_count: Tensor(shape=torch.Size([3, 1]), device=cuda:0, dtype=torch.int64, is_shared=True),\n",
      "        terminated: Tensor(shape=torch.Size([3, 1]), device=cuda:0, dtype=torch.bool, is_shared=True),\n",
      "        truncated: Tensor(shape=torch.Size([3, 1]), device=cuda:0, dtype=torch.bool, is_shared=True)},\n",
      "    batch_size=torch.Size([3]),\n",
      "    device=cuda:0,\n",
      "    is_shared=True)\n",
      "Shape of the rollout TensorDict: torch.Size([3])\n"
     ]
    }
   ],
   "source": [
    "base_env = GymEnv(\n",
    "    \"Humanoid-v4\",\n",
    "    from_pixels=True,\n",
    "    pixels_only=False,\n",
    "    device=device,\n",
    ")\n",
    "env = TransformedEnv(\n",
    "    base_env,\n",
    "    Compose(\n",
    "        ObservationNorm(in_keys=[\"observation\"]),\n",
    "        DoubleToFloat(),\n",
    "        StepCounter(),\n",
    "    ),\n",
    ")\n",
    "env.transform[0].init_stats(num_iter=200, reduce_dim=0, cat_dim=0)\n",
    "print(\"normalization constant shape:\", env.transform[0].loc.shape)\n",
    "print(\"observation_spec:\", env.observation_spec)\n",
    "print(\"reward_spec:\", env.reward_spec)\n",
    "print(\"input_spec:\", env.input_spec)\n",
    "print(\"action_spec (as defined by input_spec):\", env.action_spec)\n",
    "rollout = env.rollout(3)\n",
    "print(\"rollout of three steps:\", rollout)\n",
    "print(\"Shape of the rollout TensorDict:\", rollout.batch_size)\n",
    "if 0:\n",
    "    env.transform[0].loc = np.load(save_path + f\"weight/norm_loc_test_{10}\")\n",
    "    env.transform[0].scale = np.load(save_path + f\"weight/norm_loc_test_{10}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running policy: TensorDict(\n",
      "    fields={\n",
      "        action: Tensor(shape=torch.Size([17]), device=cuda:0, dtype=torch.float32, is_shared=True),\n",
      "        done: Tensor(shape=torch.Size([1]), device=cuda:0, dtype=torch.bool, is_shared=True),\n",
      "        loc: Tensor(shape=torch.Size([17]), device=cuda:0, dtype=torch.float32, is_shared=True),\n",
      "        observation: Tensor(shape=torch.Size([376]), device=cuda:0, dtype=torch.float32, is_shared=True),\n",
      "        pixels: Tensor(shape=torch.Size([480, 480, 3]), device=cuda:0, dtype=torch.uint8, is_shared=True),\n",
      "        sample_log_prob: Tensor(shape=torch.Size([]), device=cuda:0, dtype=torch.float32, is_shared=True),\n",
      "        scale: Tensor(shape=torch.Size([17]), device=cuda:0, dtype=torch.float32, is_shared=True),\n",
      "        step_count: Tensor(shape=torch.Size([1]), device=cuda:0, dtype=torch.int64, is_shared=True),\n",
      "        terminated: Tensor(shape=torch.Size([1]), device=cuda:0, dtype=torch.bool, is_shared=True),\n",
      "        truncated: Tensor(shape=torch.Size([1]), device=cuda:0, dtype=torch.bool, is_shared=True)},\n",
      "    batch_size=torch.Size([]),\n",
      "    device=cuda:0,\n",
      "    is_shared=True)\n",
      "Running value: TensorDict(\n",
      "    fields={\n",
      "        done: Tensor(shape=torch.Size([1]), device=cuda:0, dtype=torch.bool, is_shared=True),\n",
      "        observation: Tensor(shape=torch.Size([376]), device=cuda:0, dtype=torch.float32, is_shared=True),\n",
      "        pixels: Tensor(shape=torch.Size([480, 480, 3]), device=cuda:0, dtype=torch.uint8, is_shared=True),\n",
      "        state_value: Tensor(shape=torch.Size([1]), device=cuda:0, dtype=torch.float32, is_shared=True),\n",
      "        step_count: Tensor(shape=torch.Size([1]), device=cuda:0, dtype=torch.int64, is_shared=True),\n",
      "        terminated: Tensor(shape=torch.Size([1]), device=cuda:0, dtype=torch.bool, is_shared=True),\n",
      "        truncated: Tensor(shape=torch.Size([1]), device=cuda:0, dtype=torch.bool, is_shared=True)},\n",
      "    batch_size=torch.Size([]),\n",
      "    device=cuda:0,\n",
      "    is_shared=True)\n"
     ]
    }
   ],
   "source": [
    "actor_net = nn.Sequential(\n",
    "    nn.LayerNorm(376, device=device),\n",
    "    nn.LazyLinear(num_cells, device=device),\n",
    "    nn.LeakyReLU(),\n",
    "    nn.LazyLinear(num_cells, device=device),\n",
    "    nn.LeakyReLU(),\n",
    "    nn.LazyLinear(2 * env.action_spec.shape[-1], device=device),\n",
    "    NormalParamExtractor(),\n",
    ")\n",
    "policy_module = TensorDictModule(\n",
    "    actor_net, in_keys=[\"observation\"], out_keys=[\"loc\", \"scale\"]\n",
    ")\n",
    "policy_module = ProbabilisticActor(\n",
    "    module=policy_module,\n",
    "    spec=env.action_spec,\n",
    "    in_keys=[\"loc\", \"scale\"],\n",
    "    distribution_class=TanhNormal,\n",
    "    distribution_kwargs={\n",
    "        \"low\": env.action_spec.space.low,\n",
    "        \"high\": env.action_spec.space.high,\n",
    "    },\n",
    "    return_log_prob=True,\n",
    ")\n",
    "value_net = nn.Sequential(\n",
    "    nn.LayerNorm(376, device=device),\n",
    "    nn.LazyLinear(num_cells, device=device),\n",
    "    nn.LeakyReLU(),\n",
    "    nn.LazyLinear(num_cells, device=device),\n",
    "    nn.LeakyReLU(),\n",
    "    nn.LazyLinear(1, device=device),\n",
    ")\n",
    "value_module = ValueOperator(module=value_net, in_keys=[\"observation\"])\n",
    "print(\"Running policy:\", policy_module(env.reset()))\n",
    "print(\"Running value:\", value_module(env.reset()))\n",
    "loss_module = ClipPPOLoss(\n",
    "    actor_network=policy_module,\n",
    "    critic_network=value_module,\n",
    "    clip_epsilon=clip_epsilon,\n",
    "    entropy_bonus=bool(entropy_eps),\n",
    "    entropy_coef=entropy_eps,\n",
    "    critic_coef=1.0,\n",
    "    loss_critic_type=\"smooth_l1\",\n",
    ")\n",
    "optim = torch.optim.Adam(loss_module.parameters(), lr)\n",
    "scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(\n",
    "    optim, total_frames // frames_per_batch, 0.0\n",
    ")\n",
    "if 1:\n",
    "    checkpoint = torch.load(save_path + f\"weight/model_weights_test_{10}.pth\")\n",
    "    policy_module.load_state_dict(checkpoint[\"policy_weights\"])\n",
    "    value_module.load_state_dict(checkpoint[\"value_weights\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "collector = SyncDataCollector(\n",
    "    env,\n",
    "    policy_module,\n",
    "    frames_per_batch=frames_per_batch,\n",
    "    total_frames=total_frames,\n",
    "    split_trajs=False,\n",
    "    device=device,\n",
    ")\n",
    "replay_buffer = ReplayBuffer(\n",
    "    storage=LazyTensorStorage(max_size=frames_per_batch),\n",
    "    sampler=SamplerWithoutReplacement(),\n",
    ")\n",
    "advantage_module = GAE(\n",
    "    gamma=gamma,\n",
    "    lmbda=lmbda,\n",
    "    value_network=value_module,\n",
    "    average_gae=True,\n",
    "    device=device,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "eval cumulative reward: 5948.3174 (init: 1572.7069), eval step-count: 999, average reward=5.9561 (init=5.2252), step count (max): 999, lr policy: 0.0001:  27%|██▋       | 1343488/5000000 [7:17:14<15:29:25, 65.57it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "advantage中发现NaN！请检查归一化逻辑。\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "eval cumulative reward: 5948.3174 (init: 1572.7069), eval step-count: 999, average reward=5.9561 (init=5.2252), step count (max): 999, lr policy: 0.0001:  27%|██▋       | 1343488/5000000 [7:17:24<15:29:25, 65.57it/s]"
     ]
    },
    {
     "ename": "RuntimeError",
     "evalue": "reward中发现NaN奖励！请检查环境交互逻辑。",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mRuntimeError\u001b[39m                              Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[7]\u001b[39m\u001b[32m, line 9\u001b[39m\n\u001b[32m      7\u001b[39m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[33m\"\u001b[39m\u001b[33monservation中发现NaN！请检查归一化逻辑。\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m      8\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m tensordict_data[\u001b[33m\"\u001b[39m\u001b[33mnext\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mreward\u001b[39m\u001b[33m\"\u001b[39m].isnan().any():\n\u001b[32m----> \u001b[39m\u001b[32m9\u001b[39m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[33m\"\u001b[39m\u001b[33mreward中发现NaN奖励！请检查环境交互逻辑。\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m     10\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(num_epochs):\n\u001b[32m     11\u001b[39m     advantage_module(tensordict_data)\n",
      "\u001b[31mRuntimeError\u001b[39m: reward中发现NaN奖励！请检查环境交互逻辑。"
     ]
    }
   ],
   "source": [
    "base = 0\n",
    "logs = defaultdict(list)\n",
    "pbar = tqdm(total=total_frames)\n",
    "eval_str = \"\"\n",
    "for i, tensordict_data in enumerate(collector):\n",
    "    if tensordict_data[\"observation\"].isnan().any():\n",
    "        raise RuntimeError(\"onservation中发现NaN！请检查归一化逻辑。\")\n",
    "    if tensordict_data[\"next\", \"reward\"].isnan().any():\n",
    "        raise RuntimeError(\"reward中发现NaN奖励！请检查环境交互逻辑。\")\n",
    "    for _ in range(num_epochs):\n",
    "        advantage_module(tensordict_data)\n",
    "        if tensordict_data[\"advantage\"].isnan().any():\n",
    "            print(\"advantage中发现NaN！请检查归一化逻辑。\")\n",
    "            break\n",
    "        data_view = tensordict_data.reshape(-1)\n",
    "        replay_buffer.extend(data_view.cpu())\n",
    "        for _ in range(frames_per_batch // sub_batch_size):\n",
    "            subdata = replay_buffer.sample(sub_batch_size)\n",
    "            loss_vals = loss_module(subdata.to(device))\n",
    "            loss_value = (\n",
    "                loss_vals[\"loss_objective\"]\n",
    "                + loss_vals[\"loss_critic\"]\n",
    "                + loss_vals[\"loss_entropy\"]\n",
    "            )\n",
    "            loss_value.backward()\n",
    "            torch.nn.utils.clip_grad_norm_(loss_module.parameters(), max_grad_norm)\n",
    "            optim.step()\n",
    "            optim.zero_grad()\n",
    "    logs[\"reward\"].append(tensordict_data[\"next\", \"reward\"].mean().item())\n",
    "    pbar.update(tensordict_data.numel())\n",
    "    cum_reward_str = (\n",
    "        f\"average reward={logs['reward'][-1]:.4f} (init={logs['reward'][0]:.4f})\"\n",
    "    )\n",
    "    logs[\"step_count\"].append(tensordict_data[\"step_count\"].max().item())\n",
    "    stepcount_str = f\"step count (max): {logs['step_count'][-1]}\"\n",
    "    logs[\"lr\"].append(optim.param_groups[0][\"lr\"])\n",
    "    lr_str = f\"lr policy: {logs['lr'][-1]:.4f}\"\n",
    "    if i % 10 == 0:\n",
    "        env.eval()\n",
    "        with set_exploration_type(ExplorationType.DETERMINISTIC), torch.no_grad():\n",
    "            eval_rollout = env.rollout(1000, policy_module)\n",
    "            if eval_rollout[\"next\", \"reward\"].isnan().any():\n",
    "                raise RuntimeError(\"评估数据中发现NaN奖励！请检查环境或策略输出。\")\n",
    "            if eval_rollout[\"observation\"].isnan().any():\n",
    "                raise RuntimeError(\"评估观测中发现NaN！请检查归一化评估模式。\")\n",
    "            logs[\"eval reward\"].append(eval_rollout[\"next\", \"reward\"].mean().item())\n",
    "            logs[\"eval reward (sum)\"].append(\n",
    "                eval_rollout[\"next\", \"reward\"].sum().item()\n",
    "            )\n",
    "            logs[\"eval step_count\"].append(eval_rollout[\"step_count\"].max().item())\n",
    "            eval_str = (\n",
    "                f\"eval cumulative reward: {logs['eval reward (sum)'][-1]:.4f} \"\n",
    "                f\"(init: {logs['eval reward (sum)'][0]:.4f}), \"\n",
    "                f\"eval step-count: {logs['eval step_count'][-1]}\"\n",
    "            )\n",
    "\n",
    "            ims = eval_rollout[\"pixels\"].cpu().numpy().astype(\"uint8\")\n",
    "            fourcc = cv2.VideoWriter_fourcc(*\"mp4v\")\n",
    "            out = cv2.VideoWriter(\n",
    "                save_path + f\"video/output_test_{i + base}.mp4\",\n",
    "                fourcc,\n",
    "                30,\n",
    "                (ims.shape[2], ims.shape[1]),\n",
    "            )\n",
    "            for frame in ims:\n",
    "                out.write(frame[..., ::-1])\n",
    "            out.release()\n",
    "            del eval_rollout\n",
    "        env.train()\n",
    "        torch.save(\n",
    "            {\n",
    "                \"policy_weights\": policy_module.state_dict(),\n",
    "                \"value_weights\": value_module.state_dict(),\n",
    "            },\n",
    "            save_path + f\"weight/model_weights_test_{i + base}.pth\",\n",
    "        )\n",
    "        np.save(\n",
    "            save_path + f\"weight/norm_loc_test_{i + base}\", env.transform[0].loc.cpu()\n",
    "        )\n",
    "        np.save(\n",
    "            save_path + f\"weight/norm_scale_test_{i + base}\",\n",
    "            env.transform[0].scale.cpu(),\n",
    "        )\n",
    "    pbar.set_description(\", \".join([eval_str, cum_reward_str, stepcount_str, lr_str]))\n",
    "    scheduler.step()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# performance\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 10))\n",
    "plt.subplot(2, 2, 1)\n",
    "plt.plot(logs[\"reward\"])\n",
    "plt.title(\"training rewards (average)\")\n",
    "plt.subplot(2, 2, 2)\n",
    "plt.plot(logs[\"step_count\"])\n",
    "plt.title(\"Max step count (training)\")\n",
    "plt.subplot(2, 2, 3)\n",
    "plt.plot(logs[\"eval reward (sum)\"])\n",
    "plt.title(\"Return (test)\")\n",
    "plt.subplot(2, 2, 4)\n",
    "plt.plot(logs[\"eval step_count\"])\n",
    "plt.title(\"Max step count (test)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0cAAANECAYAAAB7LlQtAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQeYE1UXhs+yu+zSOyy9996kIwhSVbCLKOqPYsGGYsFKUbGiYgGxgA0RFSygKL333ntvS91lWbbnf85dJjtJJskkmZnMTL6XJ2Qzmczcaefcc0+5UQ6Hw0EAAAAAAAAAEOHkC3cDAAAAAAAAAMAMwDgCAAAAAAAAABhHAAAAAAAAAJALjCMAAAAAAAAAgHEEAAAAAAAAALnAOAIAAAAAAAAAGEcAAAAAAAAAkAuMIwAAAAAAAACAcQQAAAAAAAAAucA4AiFTrVo1uv/++4P6bZcuXcQLhP9aKDF9+nQqWbIkpaSkaLZNO5GZmUmVK1emzz//PNxNAQAA2/PYY4/R9ddfb9j+WJ+yXg2GkSNHUlRUFOkJdJA+wDiKAFasWCEe0osXL4a7KcBCZGdn0+uvv05PPPEEFS5cONzNMSWxsbH0zDPP0JtvvklpaWnhbg4AtmDKlCmiU8mvZcuWeXzvcDhEh5C/v+GGG8hspKamCp27aNGicDfFtOzYsUOco0OHDqn+zcGDB+mrr76il156ybnsxIkTYjubNm2iSAQ6SB9gHEWIcTRq1CjdjKPdu3fTl19+GdRv//vvP/EC5uOvv/4S13bIkCHhboqpeeCBB+js2bM0derUcDcFAFsRHx+v+FwtXryYjh07RnFxcWRG2DhinQvjyLdxxOcoEOPo448/purVq1PXrl1djCPejl7GEfdtWA8GwyuvvEJXrlwhvYEO0h4YR8CFnJycgEcfWEHx6EUw5M+fX7yseuxGc/nyZcP2NXnyZOrQoQNVrFiRzAp3QsJN8eLFqUePHmK0GwCgHX369KFffvmFsrKyXJZzJ7Bly5aUkJAQtrYBY+HwsR9//JHuuOMOQ3UG922CNcJjYmKEga830EHaA+PI5rC7+bnnnhN/84iLFKogjdbw348//rgQOg0bNhRCYM6cOeK7999/n9q3b0+lSpWiAgUKCGX066+/+s1zkUIili9fLty9ZcqUoUKFCtHNN99MZ86c8ZlzxCNt/FvOdWE3caVKlYRw6datG+3bt89j35999hnVqFFDtO+aa66hpUuXqs5j8nXsx48fp//9739Urlw5sZy//+abb1zCOkqXLi2OT25csZCKjo528dK98847QkhKeTtbtmwR54vbzcfGCp73de7cOY9rx23kEba7776bSpQoQR07dnTu/4033hDnp2DBgmIkbfv27YoKhUfVateuLfbF15K3MXfuXJ/nho1EPhfdu3dXNJquu+46Klu2rDg3DRo0oAkTJrisw6EufHxKtGvXjlq1auWy7IcffhD3F19HznG666676OjRoy7r8DVt1KgRrV+/njp37iyOWwqv+OOPP6hv375UoUIF0aaaNWvSmDFjRGhgsPdMenq6CCusVauW2CaH8Tz//PNiuTscA8/hP+fPn/d5XgEA6hkwYICQi3J5lZGRIfQQy0Ql1OgtlmEsW+UynXnrrbfE8r///ttnu9atW0c9e/YUOoD3wbqVZTjDupV1HsOyV9K5LM8ldu3aRbfddpuQdSyXWR7++eefLvuQ9OiSJUvo4YcfFsdTtGhRGjRoEF24cEHV+eP9sDHB7eF21q1bl15++WWXdTZu3Ei9e/cW2+bwada1q1atUpU7I7VR7v3h/gDLf5aHLF/5+Fjefvfddy6/u/3228XfrLukc+TL08bbY++IXCfx+q1bt3Z6T6TtSEaCFjrDPeeIj5X3wffZpEmTxO/499yOtWvX+j1vUr/j999/F22T+hdS30MOHx/fG3wOeT9ffPGF12sBHaQtMRpvD5iMW265hfbs2UM//fQTffjhh0KYM5LwZhYsWCCMEX5g+XtJELAL+6abbqKBAwcKhTRt2jQh0GbNmiWEij84V4U79NzBZIHy0UcfiX38/PPPfn/79ttvU758+Wj48OGUlJRE7777rmjH6tWrnetwh5y316lTJxo2bJjYR//+/cU+2WhQg9Kxnz59mtq2besUYnyu/vnnHxo8eDAlJyfT008/Lb5jrworLgk2erit3G42DKVzxJ3v5s2bO/N2WNEfOHBACHM2jNioYSHL76yU3AUfn3M2blhxs1HEvPbaa8I44pFVfm3YsEGMHPF1ksOCdOzYsfTggw8KRcXtZ8XO6/tKamVlwttq0aKFx3d83lmY873BRh+H33GSLBuHQ4cOFevceeedQomzspCUF3P48GFxjO+9955zGRvBr776qlDi3E42oD/55BOhzFhxs8EpwR0lVuRsPN1zzz3CeGVYGfL5ZWOV3/m68jni45XvS+09w8fCx8fKhsMK69evT1u3bhXPED9PrNjkcAeMrw2HsJoxBwIAK8LymAdTWH/xc8+wLGY5yzJg/PjxHr9Ro7dY9s6YMUPIC5aDPPDBzzcbMyznWaZ6IzExUcha1gsvvviikE8sR3h7DC9nOfPoo4+KAUHWwUyTJk3EO8t5ySPPv+eBQ9ZBLId+++038Rs5LK94HyzLObyLt81yVBpI9AbrI5Zz7PlgGcbncv/+/UJes8yV2sLrsGHEAz+8LnfA2ajg0MU2bdoEcdVIDGSy8cfn8r777hNGKBsZLCdZd7Bsf/LJJ8X1Y2OF5SsjvSvBspWPl3WpBK8/evRoIev5GPlYGDaOtdIZ3mDv5aVLl4Thyu3iPgpfa9bt/iJpWK/w/cJ6s0iRIuI83HrrrXTkyBFhBDOs+3r16kXly5cX9yUbbXys8r6bHOggjXEA2/Pee+9xj9px8OBBj+94eb58+Rzbt2/3+C41NdXlc0ZGhqNRo0aO6667zmV51apVHffdd5/z8+TJk8V2u3fv7sjJyXEuHzZsmCM6Otpx8eJF57Jrr71WvCQWLlwoflu/fn1Henq6c/nHH38slm/dulV85u9KlSrlaN26tSMzM9O53pQpU8R68m16w9uxDx482FG+fHnH2bNnXZbfddddjmLFijnPC59XPp7k5GTxefz48eJcXHPNNY4XXnhBLMvOznYUL15cHLu388r89NNPoj1LlixxLnv99dfFsgEDBrism5iY6MifP7+jb9++Luf3pZdeEuvLr0XTpk3FeoHy1VdfuZxvOUrt79mzp6NGjRrOz0lJSY64uDjHs88+67Leu+++64iKinIcPnxYfD506JA4h2+++abLerzfmJgYl+V8TblNEydOVNWmhx9+2FGwYEFHWlpawPfM999/L+6NpUuXumyT983rLl++3GX5iRMnxPJ33nnHox0AgMCQdMjatWsdn376qaNIkSLOZ/z22293dO3aVfzN8tZdvqnVWydPnnSULFnScf311wvZ0Lx5c0eVKlWE7PLFzJkznW3zxpkzZ8Q6LMPd6datm6Nx48ZOucSwHG/fvr2jdu3aHuegZcuW4hjkMpSX//HHHz7b2blzZ3HeJFkr35dE//79hS7Zv3+/iyzj3/Hv3XWRO1Ib5X0Lvibuuox1lrs++OWXX8R6rPPVcM899wj57Q5fB94Ot8WdUHUGw/qUj0mCj5W3yW05f/68czlfD17+119/+Txv/JnP+b59+5zLNm/eLJZ/8sknzmU33nijaMvx48edy/bu3Sv0otK1gA7SFoTVAbr22mtFaJQ77IaXYDc+j9bxyAx7HdTAIznykS3+LY9+8KiXP3hkT56LJI0I8agMw94PHhF66KGHhPdCgkcL2QsQ7LGz7OLRuxtvvFH8zW586cVhFHwOpOOXjodHaiQPES/jF//NbNu2TYTYSe13P68cvsbbZk8Vo3RuH3nkEZfP8+bNEyOi7JmTn1/2aLnDI448Orh3714KBCnET+lcytvP54Pbz+eRrw1/ZngkkkfreERU8nYx7DXkY61SpYr4zKNn7KVhr5H8XLNHjb1lCxcudNk3hyDwveGrTTyax9vgc87x5RxaEug9w3kOPCpZr149l3ZxOCHj3i7p97wOAEA7WDZwUjt7fvjZ5ndvIXWB6C2WMRxiy558/p4T+tnDwbLLF5Inm9vBYcuBwCFP7KHgY5LkFL9YLrF+YTnNId3uelTuiWCPFMsvX6F/7H3nqAYO9ZNkrYSkM1h3cTEk9ljJQ6DZU8Hnl70b7EUJBtapcp3H3g4O6ZP0dzDwOQpEt2uhM3zB0RHy9rj3UXzBoYEcJifBXkW+76Tf8rVhPc/XhsP+JDjEW/KgugMdpC0wjoCIl1aChT93ZDnelWOjpXABqQPsD3ehLD28auKl/f1WMrBYWMhhpRHInATux85KhY0ZDnPj45W/JAHLYRUMh5xxDLNkCEnGEYcMcEecDR/pOylXSFKQTz31lHDvs4DmbUvtUDq37m2Ujp2NBzm8HXflwW54Pp46depQ48aNRf4Zh1uoRW7YSHDIIAt3DgfhjgLvV4rjlreflQfnDa1cuVJ85pAODtfj5RLcGeB98LG4n++dO3c6z7UEh6IoFfBgA5DDUYoVKyaUDP+eQyjkbQrknuF28Tbd28TnkXFvl3Se9J7TAoBIg587ljccxsSDKdxx5JAtbwSitzjUikPt1qxZIwZNON/GHzwQxCFQHOrEodj9+vUTOUxKuYhK4WYsKziM2F22cPi5kmxxl/McAsYGjK8qb1Inm3NavMG6jg0BNlrc4YEhHrRyz/tUi7v+Zlg3qc2VCkQf+SMUnWFU/0b6vfRbvgd4QMBdVzFKyxjoIG1BzhFwGUGR4E49x21zR58nF2NhzKNXrATUlovkwgTBCrhQfhvKsbNCYFhIcqy0ElLsOJ8PjsnmETpWeqdOnRLGERs9PKLI+VF8Htn7II8T5lFD9jaxodKsWTOh7Hi/HF8s7d9XGwOBrx8bJZx8yqOEPEcE581MnDhR5Pd4Q4p7ZmEtz8XhbXEHgo9p3LhxIlafFQ+PYvJ25e1n7xsbj+w94hhwfud8LCkRl+H1WZhzHoHSNXefX0npXLDxxx0WVnBsDPKIHHeMeKT4hRdeUDyn/uDfsDHJx6gEH7ccSalJOX0AAO1gTwYbLyxjeeRcnocYit5ibwQPZDFc+Iafe5ZRvmB5xQUeOHeS83f+/fdf4aH54IMPxDJfc8JJsohzadlTpIS3zm848dbhVip4o5f+Zp0UjHGll84wW/8GOkhbYBxFAMGMJHBoGQsLFvzyMpasZMxA1apVxTsbJfI5D7jkK4+oSQZMoLARwwmSLPSVKrW5w8YQV6NjFzgLJTYa+Hxz0ikran7JkyNZgM2fP1+MOnLyp0QgYW/SsfNv5OEQPBKopDx49JS9XvziinncceDkXl/GER+HNOkeGwkS3BngEVKurCQf/XIPM2PYs8THziFqbGRwSB2fL3mYACslVgjsHZO8MoHCicncyeFRZT42CW57sPcMt2vz5s3CEFTz/Ej78pVQDAAIDh7h58R3Nj58FfQJVG9xARkOqeKiNSNGjBBFg+QVSH3B3il+cXEDNrw4PJeLP7Bc9SYzJHnNBpsa/SLJebm8Yhl+8uRJn0UjpP1wWLcvXceDV0pz+HBYGRuJ0iCQ5BVho0JumKoJkdeqX8I6iSvLsleHvT3BbicQnREuuBIs38dKFXqVljHQQdqCsLoIgDupTCCTwPLIBgsd+cgQdyDdq3SFCy5vySNJPEGbfA4MFp6huO75uDlkgpWskmJxL0XOnX02FlipcuicJKh5+ffffy8mqJPHXksjRu4jRPx7tbBSZeXKFd3k21Hahnt5cB7V5JFJfyEgXPmGPULSqKqv9rOy8tb54BA6PgfssWJjQx5Sx3B1H94mG4vu54Q/u7dfCaU2cU4WjxwHe8+wd49j/5UmN+ZwB/f5pjhckK89V9YCAGgLyy0OjeNBHfZIa6G32PvDhhZXRuWqcRxix5N2cjVKX7CscJdVHAHASHKVjQ4lncudXq4ExxXh2MDxp18YDvGW5zbxeWD55S33RDJ8uNPPOVRcAU2O1HY+V1x1j6MK5CF6XK2VjT3WZ1L+lZQfI6/OyjLw22+/JaP6JSxbue0sa0PZTiA6I1xw+1jP833L+lNuGHGUhRLQQdoCz1EEwB1dhuc3YAXAHWtWMJJQUYLjsHm0n0O9OKSBY2A5eZU71oHkrOgFd9xZUXJRAk6S584sC3guz8mCPJS4W1aW7AnhkDkO5eDkUs4TYpc7e4jk8wiwIOKcFR5948RZCVZM0tw/cuOIlQ1/x2U/WeFxPDSHuwUyYsWKj8MyeLSTPTM8gshlP1lourvUue2sjPkeYA8SGzvcKeDysL7gUStWnHy8HHYgwcv43PP9wyO5PIrJBgQrfSVlz21jTxy3VzI85fC14pLkPGorldXm9fl8zJw5U5xT/q0vOGSPRzY5DJLLw/K1Z8PUvQMTyD1z7733ijBALobB9wKX3uUOF4+o8nIemZbP1cRJ3byOFI4IANAWb2HOwegtXs6FDdgjI8nCTz/9VDzrXHKaixF4C69jg4A70ezNYrnBnieWgSzbJW8Oh3Kx7GXjiz3iLHs5/4df3B42PNgjz/qFvTxskHBu5rFjx8QgkhzutLMHm+UV6xneN/+ewwd9weWheT3OjWU5yt55lnezZ88WxScYlr0su3g9LivNuowNNzbyWEfJ5T5HCnBpbg4HZ1nOhhfrInfjSy1sUPJ2OPKCB9jY0yfNn6cEt5HlK+skqTAOw9eAvVkcKs66g/s1rLu95VIHojPCCesq7huwXuF7lfUP36N8D0nXTw50kMZoXP0OmJQxY8Y4KlasKMoTy0tv8t9Dhw5V/M3XX38tSotyCc569eqJUplKpSm9lfJ2L3UqlemWl+70Vsqby3zKkcpnupfrlMpncxu5hDaXWObSp7169fJ7Tnwd++nTp8V3lStXdsTGxjoSEhJECdZJkyZ5rMuloXlbq1evdi47duyYWMa/d4e/u/nmm0WJby4NzqVppTKc8tKv0rnmsrDucInwUaNGiZLjBQoUcHTp0sWxbds2j2vxxhtviPPC++L1+DpyeWx5aVhvzJgxQ5TdPnLkiMvyP//809GkSRNHfHy8o1q1aqJ06DfffOO1XPzAgQOdpd298dtvvzk6duzoKFSokHhxO/n8796927kO3ycNGzZU/D1f97Zt24pjrFChguP55593/Pvvv4qlYtXeM3yO+Nh4n7xuiRIlxHp83uXlfrk0PZdm5fLnAIDQ8aZD3FEq5a1Gb91yyy2iXDVPJSBHKsfsqxzyhg0bxPQKXPab91G2bFnHDTfc4Fi3bp3LeitWrBDygmWDu2zn0tmDBg0SeoX1C+tm3savv/7qcQ4WL17sGDJkiJA/hQsXFvL03LlzKs6iQ+gESdewvK5bt67j1Vdf9TgenoqBt82lo7lMOrfdnfXr1zvatGkjjoePfdy4cV5LeStNH+Gu65kvv/xSTAHB0zmoKev95JNPOmrVquWxnK9bgwYNnGWupX6CFjrDWylvnsrDHW86XE2/w113M/Pnzxcl5vmc16xZU+gYLofO11IOdJD2RPF/WhtcAIQLTqTk0SwO11IKiQLq4ZEqHv3kEUueOdyuhHrPcDgjj7JysYpQimcAAIAEe7Q5T5Qn0pZ7qSMZrsLHuUccJaGmsqAd4egK9+k5oIO0BzlHwLJwqWx32/67774TYW8cSgZCg0MeOKSOw0A4fM4OaH3PcGgkh/FwrgKUEgAA6AeHIHJoH4e+RwKc3yqHDSKuDCvXVdBB+gDPEbAsXHFm2LBhojQ0x9lyTtDXX38tqrVwcqLS3AYgssE9AwCwAvAcAS5FzzlwbBRyZUDOY+Z8MM4xdp//CmgLCjIAy8ITd3KpUU485ZF/TnodNGiQGFVCJxcogXsGAACAFeDCIj/99JOY34sLVnABqLfeeguGkQHAcwQAAAAAAAAAyDkCAAAAAAAAgFxgHAEAAAAAAACAnXOOuDwvzyzMk4KFMiEoAACAwOBobZ4cs0KFCl4n04xUoJsAAMDcusm2xhErH068BgAAEB6OHj1KlSpVCnczTAV0EwAAmFs32dY44lE56QQULVo03M0BAICIITk5WRgAkhwGeUA3AQCAuXWTbY0jKVyBlQ8UEAAAGA/CxjyBbgIAAHPrJgSDAwAAAAAAAACMIwAAAAAAAADIBcYRAAAAAAAAAMA4AgAAAAAAAIBcYBwBAAAAAAAAAIwjAAAAAAAAAMgFxhEAAAAAAAAAwDgCAAAAAAAAgFxgHAEAALA0S5YsoRtvvJEqVKggJvf7/fffXb53OBz02muvUfny5alAgQLUvXt32rt3r8s658+fp4EDB4qJWYsXL06DBw+mlJQUl3W2bNlCnTp1ovj4eDHL+rvvvmvI8QEAADAOGEcAAAAszeXLl6lp06b02WefKX7PRsz48eNp4sSJtHr1aipUqBD17NmT0tLSnOuwYbR9+3aaO3cuzZo1SxhcQ4YMcX6fnJxMPXr0oKpVq9L69evpvffeo5EjR9KkSZMMOUYAAADGEOXgITUbwoqsWLFilJSUJEYCAQAA2F/+sudo5syZ1L9/f/GZVRx7lJ599lkaPny4WMbtKleuHE2ZMoXuuusu2rlzJzVo0IDWrl1LrVq1EuvMmTOH+vTpQ8eOHRO/nzBhAr388st06tQpyp8/v1jnxRdfFF6qXbt2qW4fdBMAAIQHtfIXniMAAAC25eDBg8Kg4VA6CVaObdq0oZUrV4rP/M6hdJJhxPD6+fLlE54maZ3OnTs7DSOGvU+7d++mCxcuGHpMAAAA9CNGx20DAACwCFcysumRH9ZT9/pl6d521cgusGHEsKdIDn+WvuP3smXLunwfExNDJUuWdFmnevXqHtuQvitRooTi/tPT08VLPnIJAADujPprO11MzaQLqRnUpU4Z2pOYQlNXH6GJ97SgXo3K0xuzdtCC3Yl04Mxlxd9/c38rmrX5JJ1PzaDUjGx6rmddal2tpMd6u04l02t/bKei8WwCRNGDnarTuLl7aOSNDeng2cv0w6rDdE/bqvTtykNUP6EIfbvysMvv42LyUb9mFejd25oqtuOtv3fSuZQMsd0HJq+lU8l54ctyoqKI9r3Zh/7ZdpIen7pRLHvn1sZ0Y9MK9MgPG6hHg3JUp1wRev+/3fRA+2r06I8bxDpf3NuSejZMID2BcQQAABHM5fQsWr7vLO1NTKHFe86Il52Mo3AzduxYGjVqVLibAQAwMWmZ2TR5+SHn50W7zzj/ZkNh/1t96KtlB31u439T1rl8vn3iSjr0dl+P9e7/xtVgmbfztHi/9+vVdO5yhvh75YFz4n3NwfMev0/PyqHp647R0K61qGqpQh7fT1pyQLz/tuGYz/ZyUs+i3YlOw4h54betdP5yJi3Zc0a8JOTt+GjeXt2NI4TVAQBABPPUtE005Pv19N6/u8mOJCTkKtHTp3M7ABL8WfqO3xMTE12+z8rKEhXs5OsobUO+DyVGjBgh4tul19GjRzU6MgCAXWCDwxdalgc4fUnZkyMZRmrJygm9TWmZnsedkp7p8zepGVmkNzCOAAAggpFGDe0Kh8Kx8TJ//nyX0DbOJWrXrp34zO8XL14UVegkFixYQDk5OSI3SVqHK9hlZuYpbq5sV7duXa8hdUxcXJxI/JW/AABATma2b+NIS6xehi3KgH3AOAIAAGBpeD6iTZs2iZdUhIH/PnLkiKhe9/TTT9Mbb7xBf/75J23dupUGDRokKtBJFe3q169PvXr1ooceeojWrFlDy5cvp8cff1xUsuP1mLvvvlsUY+D5j7jk988//0wff/wxPfPMM2E9dgCA9THSONIKh8WNLF8g5wgAAIALj0/dIAo0vHFzIypfrACZnXXr1lHXrl2dnyWD5b777hPlup9//nkxFxLPW8Qeoo4dO4pS3TyZq8SPP/4oDKJu3bqJKnW33nqrmBtJXuHuv//+o6FDh1LLli2pdOnSYmJZ+VxIAAAQDJlZvi0NG9shpgTGEQAAABe4KMOltCx6RSEe3Ix06dLFZ0w+e49Gjx4tXt7gynRTp071uZ8mTZrQ0qVLQ2orAAC4k5njL+fIsKYAhNUBAADwpojzGRHcDQAAEY4Vw+r0wgyGIIwjAAAALuRc1U75eCIKAAAAYQ6rM4HF4IFD16p64QTGEQAAABeyr5ZohW0EAADGDUh5wyY2hyqjz5/e4TBpvYFxBAAAwEtYHawjAAAAxmEGQxDGEQAAABeyriYHwzgCAAD9iVRRu+bgeTIjMI4AACACOXj2MmV5SQKWJj5HQQYAAAg/ZvCm6NHO71YeDjysjvQHpbwBACDC+G39MXr2l83Uo0E5n+vlg3UEAABhNyrMWZDBvoagIZ6j48eP0z333EOlSpWiAgUKUOPGjcWkfb5YtGgRtWjRguLi4qhWrVpiIj8AAAChM2nJAfH+347TPtdDWB0AAIBIQ3fj6MKFC9ShQweKjY2lf/75h3bs2EEffPABlShRwutvDh48SH379hUznm/atImefvppevDBB+nff//Vu7kAAGB71No8cBwBAED4MYM3RU2btGimGcbkdA+re+edd6hy5co0efJk57Lq1av7/M3EiRPFOmxEMfXr16dly5bRhx9+SD179tS7yQAAYGvUlkI1omQqAADYidPJafTkTxtpULtq1LdJeVW/8SdqTWgb6cZnC/f7XiHKBp6jP//8k1q1akW33347lS1blpo3b05ffvmlz9+sXLmSunfv7rKMjSJe7o309HRKTk52eQEAAAjeIwTPEQAABMbov3bQ6oPnaejUDZb2DEUyuhtHBw4coAkTJlDt2rVFWNyjjz5KTz75JH377bdef3Pq1CkqV841UZg/s8Fz5coVxd+MHTuWihUr5nyxtwoAAEAoYXWwjgAAIBAupGZovk0HrCd7GUc5OTmisMJbb70lvEZDhgyhhx56SITOacmIESMoKSnJ+Tp69Kim2wcAALsQpTIuAcYRAACEH6uYRg6bGHG6G0fly5enBg0auCzjHKIjR454/U1CQgKdPu1aRYk/Fy1aVFS7U4Kr2vH38hcAAABP1No8sI0AACAw9JCbNrE5LIPuxhFXqtu9e7fLsj179lDVqlW9/qZdu3Y0f/58l2Vz584VywEAIFI5mXSFtp9ICnk7agstwHMEAACBESmGjCNM+42yg3E0bNgwWrVqlQir27dvH02dOpUmTZpEQ4cOdQmJGzRokPPzI488InKVnn/+edq1axd9/vnnNH36dLEtAACIVNqNXUB9xy+jo+dTDVEuKMgAAAAmIEIMLrOgu3HUunVrmjlzJv3000/UqFEjGjNmDH300Uc0cOBA5zonT550CbPjMt6zZ88W3qKmTZuKkt5fffUVyngDAAARbT+RbFC1OlhHAAAQ9rA6i1hHDrIHus9zxNxwww3i5Y0pU6Z4LOvSpQtt3LhR55YBAIAVcRgTVgfXEQAAABNhxPx7unuOAAAAmIv1hy/4XQd2EQAAmINIyWMyCzCOAAAggjhwJkXVegipAwAAY/Bn+zgsYrA5zNjQIIBxBAAAEUTipXRV68E2AgAAc2CX+YOsAowjAAAAYYnrBgCASJ1kG5gXGEcAABBBQG0DAIC12JuoLhwaaAOMIwAAiCDUBmfAiAIAAHOEzd01aRVZAYcB2VG2mAQWAACAthgRfo6oOgAAAJEIjCMAAAAeIG4eAABAJALjCAAALIYRXh14jgAAAJgNI3QTjCMAAIigsLq0zGwtmwIAACDEzrsVC3U7FFptl4rjMI4AAIaRlZ1Daw+dp/QsdNDDxf2T16paD44jAAAAkQiMIwCAYbz37266feJKGv7LlnA3BfgB8xwBAACIxHxYGEcAAMP4YskB8f7X5hPhborlMHqGdJhGAAAAIhEYRwAAYAHktpFaM+lyehbtP5NCKelZtPrAOcrJCcDAgnUEAAAgAokJdwMAAAD4R8ms4dyt/NH5vIbAdX1/ESVeSnd+HnVTQx1bCAAAIBisWMjAYcE2qwWeIwCAYSCNRZuwOj6NyWmZ1H7sAnpgivcCC3LDiPltwzHV+8OlAgAAEInAOAIAAAvgcPt745GLdO5yBi3afUaX6n8oyAAAAMYMfP24+jDZAYdNvEkwjgAAwALkuGmdEgVjnX+nputhHGm+SQAAAG78ufkEzdhwPNzNsAxRmAQWAGAn7DKqZBSzt5ykXh8toX2JKZqcuy3HklSvC9sIAAD0Z/3hC+FuAnADxhEAAJiUoVM30K5Tl+jZ6Zs8voOhCQAAgYewnUpKIzORkpYV7iYAN2AcAQCAyeFS3L6MIT3sJOQcAQDsxkszt1LbsfPpt/Xqi9MYId/tgkMXbWQ8MI4AAMCCOUd6A9MIAGA3flpzVLyPm7uHzEJWIPPPmQiHNZutChhHAABgAYzWQ9l21nwAgIhGPjWC1sDrbn1gHAEAgMWUOf+pt+lyMTVT5z0AAADQ01AzGodNDgXGEQDAMDCgFjyOCFGuAACgN5CY1iXKgI4EjCMAALAAjhz/6yTB2wMAAJYChpr5gHEEAAAWUJ7+qgDxnEhNR/9Hb/+zy7B2AQAACA04/s0HjCMAADA5B85cppX7z/kMpRv513bxPnHxfkPbBgAAVmbLsYv0w6rDmoUnR0r0uENhwM4udl5MuBsAAIhcVh04Jybk69+8ItmdfYkplJmdQ/XLF1W1/tZjSS6fH/1xg1elZBeFBAAARiC3g276dLl4L104P/VqVD70beu8PtAfGEcAgLBx16RV4p0NhroJRciuZOc4qPu4xeLvrSN7UJH4WL+/ufHTZV6/M6JaHQAARBJ7TqdQr0bhboV1cIRJCRnhmUNYHQAg7JxMukJ2Jisnr5rCuZQMTbcHAADAPATaeUe1UfMB4wgAEHbyyUpzsqLIyrZX5z9Kpi7VqMGMLN/Hn5nlQBIvAABoCGRq6DhschJhHAEAwk50vjzjYeBXq6nDOwsoLTPb7+/2n0mhF3/bQkfOpZKZuJSWSXd/uYp+WnMkqN9/OG+Pz+/T3YxHEWZnD50EAAC646/6ZyhEynx+jnCF1RlwfmEcAQDCQk6OQ9FztGL/OTqdnE7rD1/wu407v1hJ09YepfsnryEzwRXj+DhGzNga1MjazA3HVXiWYA0BAIDZOt2BGg0Y2DIfuhtHI0eOFLPZyl/16tXz+ZuPPvqI6tatSwUKFKDKlSvTsGHDKC0tTe+mAgB0Rq57smUaQeY4CoizV/N3Dpy9TGYi+UqW11FKhwajmlz1zn399Cz/njYAAADKwEgJDAdKeYdGw4YNad68eXk7jfG+26lTp9KLL75I33zzDbVv35727NlD999/vzCqxo0bZ0RzAQAGVXCTiImOUpVrYwVe+2Mbfb/qsK5Kl8+TfJuDp6yjS2muBhkAAADze6D0DPEDJjaO2BhKSEhQte6KFSuoQ4cOdPfdd4vP1apVowEDBtDq1at1biUAwEiyFMLqJi8/SFbnu5WuhpE7agwlf+u4G5Fbj7vOiQQAACAwGRspuUJ6nsPPFu4jO2BIztHevXupQoUKVKNGDRo4cCAdOeI9SZm9RevXr6c1a3JzCA4cOEB///039enTx4imAgA0yifyl1uTne1pHO1NTNG9bVbAn/2042QynUhCqDEAAGglY9V6+DnqQcvpJ+wUzvfF4gNkB3Q3jtq0aUNTpkyhOXPm0IQJE+jgwYPUqVMnunTpkuL67DEaPXo0dezYkWJjY6lmzZrUpUsXeumll3zuJz09nZKTk11eAADjYcXR95Nlouqc2rl6pGp1dlIScuTHtetUMl1MDW2uowW7EunJnzaG3rAIITs7m1599VWqXr26yGVlvTJmzBgXA57/fu2116h8+fJine7du4uBPTnnz58XA3xFixal4sWL0+DBgyklBQY9AJHEA1PWUruxC2jJnjMUyTjCtF9bVKvr3bs33X777dSkSRPq2bOn8AJdvHiRpk+frrj+okWL6K233qLPP/+cNmzYQDNmzKDZs2cLReaLsWPHUrFixZwvLuQAADAeLq+982SyqNamNufI6kYRF0g4el5dOfHHp26ka96c73OdUM9HsHNNPHN9HbIj77zzjhic+/TTT2nnzp3i87vvvkuffPKJcx3+PH78eJo4caII4y5UqJDQWfJiQGwYbd++nebOnUuzZs2iJUuW0JAhQ8J0VACAcCAZRd+uOKTJ9qyu/+yIITlHcni0rU6dOrRvn3JcIo/u3XvvvfTggw+Kz40bN6bLly8LBfTyyy9TvnzK9tyIESPomWeecX5mzxEMJADCC3fSuZiK87OXnKOcq9rBqomp9369mlYdOE9THmit+L37cWX4neQ2tPPApzOY0TX5fFN2gnNZ+/XrR3379nXmsv7000/O8G2+T7lK6iuvvCLWY7777jsqV64c/f7773TXXXcJo4ojINauXUutWrUS67BxxSHf77//vggdBwBYF608EoFuxqp6z2Fjq87weY44BGH//v0idEGJ1NRUDwMoOjra74WIi4sToQ7yFwDAGPjZfOX3rQElY0oGkfg9WRs2jJgfVh0xxbwXVj+fWsO5rPPnzxfVT5nNmzfTsmXLRGQDw+Hep06dEqF0EhyBwGHhK1euFJ/5nQf3JMOI4fVZX/kqGISQbwDMh5KMtXFf31ZEBWx+mtBzNHz4cLrxxhupatWqdOLECXr99deFscMV6JhBgwZRxYoVRVgcw+tyye7mzZsLxcQeJvYm8XLJSAIAmIudJy85DYPrG5RT5cGQK6I9pz1zEKeuOUINKxSl4gXzU6QRqo7OHUgKXIHYtVoTTw/BRgnPscd6hHOQ3nzzTREmx7BhxLCnSA5/lr7j97Jly3pUYi1ZsqRzHSVYt40aNUqHowIAWIXES2licu/bWlaiUoXjbGGUOci+6G4cHTt2TBhC586dozJlyohCC6tWrRJ/M1y5Tu4p4rAGDsPh9+PHj4v12DBiRQYAMCdXMtVNQBrlRaA+/+sW8d65Tq5cYGZvOUnnUtJp2pB2ZBWuZGaZQokEu7/tJ+zp1eAc1x9//FHMo8fz7m3atImefvppEQp333336bpvhHwDYA0CHRwKZP1BX6+hXacu0frDF2jSoDzvs5Vx2Ng60t04mjZtms/vuQCD+0gce5f4BQCwBl69QwFu5/iFVMVwNTMXYpCzfJ9nEYrNRy/S3B2nDY3lvpiaSWWKuI5OqmHfaXtWXnvuueeE94hzh6Rc1sOHDwuvDhtH0jx8p0+fdgn55s/NmjUTf/M6iYmJLtvNysoSFex8zePHId/8AgCYj/k7TxvS2WfDiFEqVGRjG8OyGF6QAQBgP4KJxlJSRNJ8R1qzL/ESrTxwnga0rkwx0dqkWnK1vXZj5/stYtDvs+UBbztUZdn6zXl0TfWSAf/OrmF13nJZc66Wk+cS32zgcF6SZAyxh4dziR599FHxuV27dqLSKs/D17JlS7FswYIFYhscAg4AsBK5UvbLpcbOy1OsQKy3plgQR1j2aotS3iDymLz8IN3wyVK6cDm0uVyAby6lZdLvG4+L93Ajr0gnJyMrhx79YT39tOaIqgo95xTumSnLD4bcvu7jltCrv28TeUxaxpCfTcmg08npZEbWHDyv2XW0OlJoNk8LcejQIZo5c6bIbb355pudx81hdm+88Qb9+eeftHXrVpEPy2F3/fv3F+vUr1+fevXqRQ899JCocrd8+XJ6/PHHhTcKleoAAN44fjFvwlibiljbAeMIaM6ov3bQtuPJNH6B6wSKQFuemb6Znv55k+kmA5V7hH5Zf5T+2XaKRszY6nM9ifMKxtHIv3aI0DQt2KTRdhhZJXLbxHLbtJK3KLl922230WOPPSaMHC4U9PDDD7vMn/f888/TE088IaaNaN26taisyqW74+Pjnetw3hIXdejWrZso4c05tJMmTQrTUQEAwitr1QnMfp8ut2kpb7ItCKsDupGari5JHwSHlMeycLd5Z+lOvuLdqxWIXD2dnDcRp1kINS8oPSub4mKiTTV/hF1HNYsUKSLmMeKXN9h7NHr0aPHyBlem46IOAACg1gN/NiU9Yo0MqwLPEdCNbC9P/PrD52lfoj0TvyOVqCDCtPQyAI6cS6WbPl1Gs7ac8Phu5sbjmu0n1OZ/vnC/921TeNAr5wsAAMyEmQwSEzUlItqtBhhHQDdyFOKOjl1IpVsnrKTu4xaHpU1Af+QhAr762tPXHdNl/y/8toW2HEuix6duVFSIK/afJTPgsx1h0jowjQAAAEQ6MI6AbuQoDM0cPHs5LG0B+iI3guSX3ddM1hMXe/echGIrJLmF8qVmuM49tP/MZVOMPJpp5NLuBRkAAMCsGBlGzVVWtcIRJh1mxH5hHAHdyDZh5w8YK7jcE/yN6Hy733Yj/9zu8jkzK4fu/Xo1fb5oX4j7Ce0G9/XrcD06sI0AAEA/ean0G4cJJ2yPdGAcAUPD6nx5EoB1kV9XtWF1gW0/+FG4WVtOunz+Y/MJWrr3LL07Z7dpR6/CVpAhLHsFAABjkSRspI3hRtlATxkBjCOgG1lXJ1gEkYVcXr719y5d9jFm1g4a+/dOl2Xbjid57J9xn6T1iluYnZZho4Gw/vAFGvbzJjITKMgAAAChEagUNdLG0FLEO7TbVID71X/PMI6AbmTDNqJIzznSAy6L+vWyg/TFEteZzRfvOaMoOGPcjCOt2qfFZrxVz0NYHQAAAK1zjBC9ow4YR0A3lEbW5Z0vs1QNi3SysnMUQyDNNKoj32KWn2Q2T8+RPmJO37A6CgsoyAAAAMaip7ifvu6o276sX5DBCGAcAd3wF3b012bPeWiAJ2mZ2XTgjD7zQmVk5dC17y2imz/3PYO3mQSmP+Huft+5e460bInd0O1UAQCAiTBVvoyObdlxItmoXRkGqtUBS6NUMvKfbfLkePTE1ND/s+V03QeLaene3LAx5sTFK5pse8/pS3T84hXafCw3XydY5A6HUHNxQsV97+45Rw4reI7CZHgh5AIAEAloIWGtKC0dNtBTRgDjCOiGe+dx/eHz9MOqIxSJJCan0cfz9tLp5LSAf7vr1CXxPmNDXn5KpkYJXfLthDKS5lqtTl/PhLdmOkMD/RRk0Ao91UI47Mt6CUVIpwhEAAAwPVp19gONTnZEqsfMxEAVAt1Ytu+sCAlz7+TnETkP6eBv19GH8/bQ4G/XarI9reRbpix/R7NCBT62o5ehwnwwdw+lZ2UbFlanr+fIeH5+uB08RwCAyEIHYWtm+0NTz5FDw42ZbL8wjoCuTFi03/m3e8frpzWuiYJ2ZuvVMtPbjrvG/5qhGIOEQ7ORMofXEasYDVwTvtq58chFj+/zuRlH+xJDy9/6Y9NxkaN1IumKfiN5YVA6bLiiHgMAIFIJdHBIK3lppJGh5b4cJjYCQwXGEdCVTUcvOv9Gx8sccGf8tT+2CcM1U5YXppW73dtmeHmwnqPAJoEl3TiXkk5PTdskjLAxf+3QZJtK7dU7b6tIXIzHMr40qFYHAIgE9BSxZhKjW45dpG9XHMrT7xoed46NrSMYR0BX5ELCRPLCEH5df4xu+Xw5JV4KPM/IH6GIJPZefbfyML0zZ5cuniNv28l2OII2juTb9GfEuQtsX7s8ci5VdRvOX86glm/Mc36+eCWTtEDpaPRWOU90q+WxDCF1AABgPHoWNuBiS6//uZ1mbZEXw7L6JLD6A+MIhJWkVG06mGZk+C+bacORi/TOP7uD+v24/3bTPV+tdn7Wqut6ITUj5JwjNlC+X3mI1hw8r/qastGiZ85Rbrs8j8NXp/+2iSt8bm/GhmPU5+OldPR8Km06esFvNcZgUDL29E6aVZr7iQ1clPIGAEQSZqi4ZoQDZu/VcHItjzcHniMAgiOfzKWg5Gru99kysjsp6cEZgOMX7BNFLSS0EkPpWTmKwi0QQcftevWP7XTHFys9DJAHv1un2nAxAl8hDomX0n3+9pnpm2nHyWR65fdtHkaWnopBwzl5FYmOUj5PsI0AAMBYTiVpH13iTpQuOUcOsiswjoCuRPkZwT8UQFgT0G7i11AJ9rppUYLcnzzWw2hJSc/ysBwupWVpsu1wqBclDx4/n8g5AgBEAooe+zB5kZI0CtFWg5ZHmKPNjCKmNMpgHAFdcelsRWi/y/05vswd7ZC36Qh6m/Ly6iv3n5NtM28Uy18ujvulVNOn5u1rNT+T133wP9mpuZKRrVBCPnA4hE6v2zccg29KYXVsL8ltphIFY41tFAAAmJSf1x4RVUrPpqSrCNn2ri3CnduppWGRA88RAMFx/rJckACmx4dLgvqdr/PX8PV/advVcuGBhNV9v+qw8+8rV42mtmPnU+f3FlJymvfRLLkxNHn5QdWGi15zDrnvR+K5Xzdrs02HQzevSjhGK6MVJH/u8eUdY8H8nhXtAADADjgCNFxe+G2rqFL6wX97yMpo6jlykG2BcQR0hQsS/LX5hPjbW+eSE/vXH/ZM7Lcrxy+GPj+O0rmcuDhvTilf8ESpSrz42xaXzyd8tFOuREYFUNK6ZdUSpDdyga1VhR6utKcX4Rh8k+cC5i0zvh0AAGAW1AxUpWZoE04dLpBzpA4YR0B33vvXd7U2Tuy/dUJuYj8IpcIZBew5kvPfjtMu2/W1Pfe+tZp98zpaeF98touidDE2smRV/exAkXjPkLnca2Ov4wQAACOLTJkVqa3aVqsj2wLjCBj2UFpIjoSdFbIqdRL+5JBaoZee6T3vR25Y+DZCAsdhwEhT7jnQfh/CsCP7cH2DcuFuAgAAhB25SlKTD2R5PYBJYFUB4wgYhpVGWbQkGPHx3K+uIW5aVo7xFlbnMdlqAC1Xsy4bRkaIUj1GszisTq/7NzwFGZQPxsa6DgAA8lCQdVppqEjp6+SESWEYsVsYR8AwIkVgqOXMpXR65Pv1tHjPGY/vlDws8tPnCEFQ+Srl7c2zc+xCKj3z8ybafiIp6GuZ6zmioHj4+/W0/vAFVQpMD+8Un1u9qgyFq3zsmP6N6IYm5enJ62rRmH4Nw9IGAACwFBbvx2ipbRw2HkyDcQQMI9wlLMOFNwEyetYOmrP9FN33zRrP3wSzH4VlB86k0Hv/7qILlzOcy7JUulbk7R764waasfE49R2/TPFaqs05CkWW3jphhYqd6JM1k5NjL88Rc2/bqvTp3S3omR516d521cLTCAAAAIahpb7JsbF1hFqtQHeibOw5Yi/FG7N3UuUSBej+DtUD+u1pH7NiByNzlDwmvT5eKjxFh86m0mcDW/jdxrydiYrL95xO0STpSAuvzl73trjvRq+wOrI/9lV1AAAQuYO8UrvtUJDBYYCmgucI2AouZ33DJ0sNm3H60LlU+nrZQRr51w5KSg1wnz5krP/QMXXLpBC6TUcvytbzvu1Hfljvc3uBtEcvHvxunfNvpdQZPUazOJ9r2tqjpAcwSAAAwFiClbsu89qrsJOUwubDCU+MrhU5NvYcwTgCtuLtf3bRtuPJ9PXSA4bsLys7L3/nsobzH5xOzps8Vy1yA8idmGhtR7uCcxw5aOlezyp8oRCTT0GEhSCvd5+6RFNXHxFhdHKycxz059X5urTGTHNFmKktAABgdZTC5sPJh/P2arYth431BcLqgO5Ic9toMceNWrzN5aM18slBvYsJ5W8upublAcnZl+g7bMwb5y5nUFpmNsXHRvusTqZWnMm9V/JLdzYl3eNaqnFzX8nUbsRKQthGbpsNRVz3/GiJeI+LyUe3tqwk26aOk8DqtmUAAABayl9rBtXl6fB1h85bP6zOof8+4DkCxuUcGbhPo55ZteWz3WEvhEcez1WOXkgN+ghT0pW9VzFeSjf73IOXk/jBf3s8ruUCL7lKctJ8zK+kJezlCZUNR3Ir4xmhBNzP84mLV/TbGQAAgKC9HlbPndYyFC7Hxp4j3Y2jkSNHilFm+atevXo+f3Px4kUaOnQolS9fnuLi4qhOnTr0999/691UoDN6ChX2Zhw5l2q4u1cuHLztU2nxm7N3eN1mdAgnytths8GQejXsT+2pka8mb9EVhfDBD+buUdE27a+JksEVqIeKvW3uZMrCJRkjdUD7txdQuLCvqgMAAGOKM5jZftJyoC/HxgrDkLC6hg0b0rx58/J2GuN9txkZGXT99ddT2bJl6ddff6WKFSvS4cOHqXjx4kY0FViUVm/k3V9G4mocaVPxxquXR4XE9Rb+tf/MZbp+3BJa8nxX1SFivoyZYOc50ptg9vHW3ztpdL9GLsuysg2U+jZWMAAAYKuCDKY2fbwjtdo9n9aKOUcOuxhHbAwlJCSoWvebb76h8+fP04oVKyg2NlYsq1YNc3BYmjDIEqOeWTVyRmmVU8ney3jL84P8bigAjl+84jXszh/uOUZBGUcmNQJ+W3/MwziS55LlomfOkcPpwTp6Xk1IpX6Y9RoBAIAeBNrBR1hdHloaWmbDkJyjvXv3UoUKFahGjRo0cOBAOnLkiNd1//zzT2rXrp0IqytXrhw1atSI3nrrLcrO1j6ZGxiLkSMuDpN7jnzh1ThSg582bDueRD+sOhLypqw6eqaEUqGQ2Oh8hhkN0ra5GMT1H+YWhAAAAAC0Rkt7Jtu+tpH+nqM2bdrQlClTqG7dunTy5EkaNWoUderUibZt20ZFihTxWP/AgQO0YMECYURxntG+ffvoscceo8zMTHr99de97ic9PV28JJKTk3U7JhAYB85cpiV7zhg64mKY50gmabSqaKbGOPJ2fP5aMPCr1arbEew+fGwx6F86t+Dnwmp13WPdSp/rmXgqbfmwLGcOAACA+Qi1HxMuz5O0XzsUUXAYcAy6e4569+5Nt99+OzVp0oR69uwpDB4uuDB9+nTF9XNyckS+0aRJk6hly5Z055130ssvv0wTJ070uZ+xY8dSsWLFnK/KlSvrdEQgGAZ9s8ZGvgblURh+XhMvpdGBM8GV4pbwWvJcttibaNBWZmibc6TFiNVLM7eR1igdSj6PUuWRQaQcJwAgsgleV8pngSXLYYecIyMwvJQ3F1bg6nPsEVKCK9Tx99HReXO11K9fn06dOiWKNXhjxIgRlJSU5HwdParPbPbAGih5cS5czvA6t5A7o/7aTs//utnveu6jMNe8OZ+u+2AxJcpyigIVIGrWN1omRQUw4ayeJbZ/WnNE+1G5KP/b0Teszr4KBgAA7IQaHWPmvCQbpwlZ2zhKSUmh/fv3CyNIiQ4dOgjDiT1IEnv27BHr58+f3+t2ueR30aJFXV7AXBj5TLr3NzOycqj5mLnUbPRcynIr0+wOrzt5+SGavu6Y3wR5l5wj2fLdpy/pXORBeaXVB89Rn4+X0vrDoU/05q3PPnfHaXF+AsXK7nw9DRgznRUYagAA4B0T2z2218MSDjsYR8OHD6fFixfToUOHRAW6m2++WXiFBgwYIL4fNGiQ8PpIPProo6Ja3VNPPSWMotmzZ4uCDFygAVibcD6Tco/R5fRs1YaHP2+HfBJYr/McqW+mz+3I+dFLUYWnpm2iHSeT6dYJK0krZm85SZdkVe5SM7JNe/0vB1GNT42y07PpZtJVt7WsFO4mAACAaTGzV0hNuL6Z9I2Z0d04OnbsmDCEuCDDHXfcQaVKlaJVq1ZRmTJlxPdcuY4LNUhwrtC///5La9euFXlKTz75pDCUXnzxRb2bCiwyYuE+QWc4BaE3z1EoqPEcfb/qMOmN1IyhUzdYZsRq/s7EoH8rN0oNrOStWSEPLbipaYVwNwEAAHRHkrty6fvRvL1kdzynqQgeh3lUl/Wq1U2bNs3n94sWLfJYxqW82YAC9kLtc7TxyAVatPsMPda1JsXF5OWeMRzm1uX9RXRn68r01s2Nve8rhKc2kJ/qUcrbLG5vrZthRKxzgfyu94tWx6tr081xuX0XAwEAAGD5aSy07F84wqW8HDbMOQKRi1qD5ebPV9DH8/fSN8s881omLTkgQt2mrj5iyLPjr8lyQeOt2AMbetY0jrRtx/7E0Kr4qWHGhmPBhxv4WAe5OAAAAOTjR1EWNKC0VGUOB9Ghs5dtqR9hHAHT4P6A7U28FKZ2qF9XnnN028S8PJ9QZIUN5Yzg2V/8V/8LleS0IHKOruoxXwI+S0e3l00vNwAARCRmCpXWk7H/7BKRPG/O3kl2A8YRCIlLaZkaemG0G30JxcCQe262nUiiWyes8Fr9TQ8vj7dtGj0aFRniPS9cc8vxJK/fp2fpl+dmV2MYAADUkpaZTccuGDcRtiR33eXv5qMX6aulB7zOB2Ren1D4+GrZQbIbMI5AUKRnZdO3Kw5R45H/0WcLleesCnQ0RUvXrK99vfvvLrrnq9VeCzvIf/n41I20/vAFUf2N2/fUtI00fn5e0qY3h0IoqRvetmn0aFSkdNr5UnV6dyHd8vmK8JSdjygzFAAAPOkzfil1fGchbT3mfZDKCPp9tpzemL2TfvMSoi3Py/SWo+lrINPOxtWYWTsM2Y8tSnkDe3Ltu4vo9T+3i7/f+3e3c/n2E0mqQtBUeY50kiI/rj5Cy/ad9VrZzJuRtvbQBfpj0wkaN3ePXy/PvhDya0yTcxQhnfZLQYTiaYlJLjcAAISNA2cui/dZW08Yul9v/Yw9IcxVGCh2UQFf+/EgFQqhYJLRwDgCQXEqOU1x+YXLmUELAC2NAjUhaFlerDWHD7e/2jaP+iv4ERRv7nygD3rmEwEAADAvkTI49fvG43TTp8vC2oabmllnqgjdS3mDyCIuNp8uYXM8ipN0JVO1N0nNet4MKIcXD5dRVY69huoZ7JDffjyZ2tcsbeg+I5EI0c0AAGAqucsDkZuOXgzod6H2A5TkvRGafa8B1WKNwojqeDCOgKbExfgwjvz8lkt0e6PHh0vEe/f65UgrvAk5b+FkSsaJHs+oWcLq3vx7Z0AFN+yEkZdAS0E/5YHWdP/ktZptDwAA7Mrvm46HuwkRhcMcXRtVIKwOaEp+H8aRP+soK9v/k3Pk/GXPzSo8cWpGYqICfICN8hx56yyHIwdo/AJ1xTaAORQGJnEFAAD9vCn5VMhYX6tEsoSOibbO0cM4AgGTeMkz36jai7Pp+MUrPkO//HXuM9yqx0WF0LlU00n07jnysn4A64aClyJ6ANBvj7YLdxMAAMD6+FHeXgdJvfwN/FOqUBzd164q1UsoQqGAanXAlNw1aZXi8ld/3+YzJMxf3ru30tr64SXnSI1U1BFv52HWlpPUfux82nIssBhpoC/R+YxTkfUSivr8HsoaAAD8w4OxVgrzsgNRUUSj+jWiV/o2ILMD4wgEXXLTc3mKT2HjTxC5GwVqI4QcwRZkiArMiFNyp2uVLzLwq1WUlJqp6EGTyMjKoRNJafToDxvIjpgrIsxhWI5YID831zkCAAD1vPX3Trr369U+84vNjh4y2LpnI7C+kNFFpUIBxhHQjEPnUulyRlbQYXVsHA2d6rvjr1wUQSnnSEVYXYDtXLH/nM99hsLyfefokwV7VXnQzl/OIDtSOC4y68NomUsG4wkAYFYmLTlAS/eepaV7z5BVcZ0ENqxNMRUOAwf5jPD4wTgCmnL4XGrQN3RKejbN3nIy4H1OWXHI78PnCCSx0ks7x8/fq+vDKSWHZmb5No6uKMy3BCJEqVho5A0AAIItvhRuQmlhoJ1/O0h1h4p1rGRMwjgCAfH+v7t9fu/Lo+Lv4eGwsWA6gm/M3hlk0QYv64ap3PbiPWd8htUB49Di8japVIzublPF/74C2KaVlIvZOH78ON1zzz1UqlQpKlCgADVu3JjWrVvnIrtee+01Kl++vPi+e/futHdv3oAIc/78eRo4cCAVLVqUihcvToMHD6aUFPvMHwIA8I0aERyJuUw5NjtoGEdANRdTM+jThb5LO/t8PPw8PFkaGgVRIYQuqXnIpTX0kAeZFhhVszvJaZnifleDt3ugYP5oul7DebnsMiIbDi5cuEAdOnSg2NhY+ueff2jHjh30wQcfUIkSJZzrvPvuuzR+/HiaOHEirV69mgoVKkQ9e/aktLS86pxsGG3fvp3mzp1Ls2bNoiVLltCQIUPCdFQAAMNDmjFAFXS/SatTZ8S0JpEZ5A9067TzjNNev/Pz82y3h8vfKPn0tUfpjtaVFb/zCKtzqA+rU2PwHLtwhaqXLkR64O5BC5ZZW06QpTBRv/7vrafEywi0zF+z2+idVrzzzjtUuXJlmjx5snNZ9erVXa7BRx99RK+88gr169dPLPvuu++oXLly9Pvvv9Ndd91FO3fupDlz5tDatWupVatWYp1PPvmE+vTpQ++//z5VqFAhDEcGADAbgXr4HREXHm5+4DkCmuIIIVfG3XhKVzAS5CMGz/+2JbTJMEMIq5OKJ+gxgqFVB/fxqRvJSthBQbij5v7QMqwOtpEyf/75pzBobr/9dipbtiw1b96cvvzyS+f3Bw8epFOnTolQOolixYpRmzZtaOXKleIzv3MonWQYMbx+vnz5hKfJG+np6ZScnOzyAgBYM6/S7O0LFw6HvcLCYRwBwx6QNH/GkZt1NHPjcY9l7gaUt1A8z7A6/+uYpSQlRv/tg5pLqeXlxp2jzIEDB2jChAlUu3Zt+vfff+nRRx+lJ598kr799lvxPRtGDHuK5PBn6Tt+Z8NKTkxMDJUsWdK5jhJjx44Vhpb0Yg8WAJGMr06yESFTavA63aGs7VEa9Q+0rn4bDnIMPAZUqwOWI5RJYLMUVkh1M6j2Xa3oJpGc5qV0uEdYnUOXERA9HlLUY9CfhKLxZB60uzftoGT1ICcnh1q0aEFvvfWW8BpxntBDDz0k8ov0ZsSIEZSUlOR8HT16VPd9AmA21OZw2oFADTwLT/sUYLU667iOYBwBTfHZOfPTcVOaGM7fo9RizFxVIzda5xzp+Yijg6s9j3apGZb9ankpm1YuTnExvkU27hxluAJdgwaus7LXr1+fjhw5Iv5OSEgQ76dPn3ZZhz9L3/F7YmKiy/dZWVmigp20jhJxcXGiup38BUAkwTqt2WhlXW3WsDVvBk6orbOSgRDJES8wjoCm+Ho8/BZkUDKOdJQj3kt5a+tlinQhYwZquBXPMEo/FYn3X/NG7eWe+Wh7oVgn3tMy5G1FGlypbvdu12kI9uzZQ1WrVnUWZ2ADZ/78+c7vOTeIc4natWsnPvP7xYsXaf369c51FixYILxSnJsEAFAm0uSSWQw8I3EEEvGCSWBBxCWXO4Lv9LtXqwsFdfUYPFc6cyk9rImFny7YawsXu9nQcrSuWIFY1eteU70k3dcutwPuDbWXO1++3GO4tk4ZDbYWWQwbNoxWrVolwur27dtHU6dOpUmTJtHQoUOd98fTTz9Nb7zxhijesHXrVho0aJCoQNe/f3+np6lXr14iHG/NmjW0fPlyevzxx0UlO1SqAyAypJJLzpFNvUDBYJZcMa2AcQScnEy6QoOnrKVle88GvY33fEwS66/Tr1QGXKsRGDWTwH638hC1fnMefThvj9/tSe3SWhy8/98eeI5Mjr/QNjmsPEf1a0T/PNXJmIIMbtsqX8xMuVXho3Xr1jRz5kz66aefqFGjRjRmzBhRupvnLZJ4/vnn6YknnhD5SLw+T+7Kpbvj4/PO4Y8//kj16tWjbt26iRLeHTt2FEYWAEB9qPiCXYnU66MltOOE9So3RqJXyJ07W3kWlVEzqGslWxLzHAEnL/y2lZbsOUPzdyXSobf7BrWNlPSsoHNplAoyBDsaIe1q8vKDtPnoRXqyW22Pddyf09f+2C7e/9gU3vmBfM0VZWf0zLXSUiYHc3nqly9KFYsXoOMXr+g64ua+pXF3NKMBX64KaltWUmRquOGGG8TLlyE7evRo8fIGV6ZjrxMAIHiZ+ePq3Fy/Id+vo2UvXEdWwm5yMRjyKwwQGjWo+86tjalN9VK67wfGEXByUqHjpiVKOUX+jAJ+3oLpNEsdzlF/7RDvdRMUkqCjzNmh3336kubbBFoSrMGu/LtAbyGfZXAj064GAJgYbwNAvgZTDSEIeRlqt8EOBZeiooItZBV6p6tW2cJUzS2HWA9gHAG/lv/WY0kUEx1FpQrnD3H7vr+/eMWz1GfQYsTth8lpmZo+qHqOHq06cJ4iET1VhpbXy8y6zW5x3wAA6+N1ziCyRpvlZchTM3zP1yjwOY+TPXEEoBhDM5KMuWuQc2Rjfl57hK59byEdOOM6N5A3lG7tC5cz6MZPl1Hvj5eG3Cn053Z96+9disvn7nAtr6uGqWuOUNu38ipPzVPYRigdZuc8R8FvAriRnpVjCeMo2PABb7/adSo5Igw3AEBkYnW5NPyXzc6/TyRdcUkFYKOA519UGw5v9XPBKKlTu+UcwTiyeQ7R4XOpNGLG1qAf2r2ySVdDjSn1F1an3CYHDfk+r3SuWi6lZdGp5DTF45AI5TnNwUStmhPM/RGOJFqtWzns583U5q15urQNniQAQLgxqxzi6rRqWLYvr0hVfEy08+/0zGz64L891H3cYhr7z05V27JrwSWHSa9xsMA4igAys3OCdotekLmTQ+28KhVc8Nsm0o9QynD+vO4oPT1tI1xHFqFb/bIun0MxlYLVbb5+dzpZnZL2vw/XnVQrpX9sNgAA+MKs9sCMjcdVrSfvusiLEaRl5dCnC/eJv79cetDS5yLUvlOOqpwj6wDjCPi8ueUPcqgPtdkSEUNtz+9hrmpnN+olFNFlu1wprki859xEpQrlt8V97I0Zj7WnCsULeCxvVbVEWNoDAIhMrCEx1cl8uV3AnqNQtmUncgIY/NYipUFvYBxpSFZ2Dt38+XJ6ij0KJkKth0TZ3esIc1hdSLv0vW3ZQ33v16uD3IY9BV04+Pr+1rpsNz42n+pypGoI9oprda+orVbXooqyEdS0cnGf208omjuvT9e6rt42AAAIBquHknnruwSTJxuhM3UIkHMUoew7k0Ibj1wU8+SkZwU+ohBulOSXfFmoYXW7TgVRotqh3wMlHdvW40m0NISJb4E28DxAehCTL0pT44jz2cyKFgbY70M70Bv9G9GIPvU0aRMAILLxWq1OQbmbsQMt7/rIj6VtDeX5dqJsPqAaFWQpb032bcxuYBxpSaH8eZXREzXKITDyZvLn7g11xIONkEAxQpCEUiVt6tXJ7IB5icmnLOaivRhN/ihTJM7rd70aJnj9Tivl4au4hBb7SCgWT/e0rUoFZfIMAACCJgC5ZCUnU/GCnuHakeo5cqi4yFoWRtIbGEc6EUzxAb1QOxIjb/Ffm0/YPlZWepizQig9t/lY4AYfMBaeo0txeZDGUY8G5bx+N/HelhRObPaIAgBsgNXD6rwRzGHZ4VREBWnkrD5onTkcdTeORo4cKVyn8le9eurCNaZNmybW79+/P1kB+U1vJmGg9kaWt/mJn3LzpuRHkR2GY9J1l1e3jbLc9sabERTtxaPkj+d71guqkIQRT4+afZhINAEAIgArihweDD549rJHikTo8tOKZ8M/as7LiYu5c0RZwX9kSNxEw4YNad68vHk8YmL87/bQoUM0fPhw6tSpE5n54TmRlKaYK2FFL4u/csLhMCKMOIvhMPrMChcvSMu0l7XozQgK0nFExQrGimf++FVBf23dMsHl0+lSkAH3MgDAXHiTS2buJC/dd5a+XXmYWlfTtrqniYKKLEmUQUlphoTVsTGUkJDgfJUuXdrn+tnZ2TRw4EAaNWoU1ahRg8zK+//tpg5vL6Cvlh7wiLk01QOg0b0UDm8YC1W9HgXpaLLhOrJkTLBaYr2E1eldTtS9fLgRj4+ZxA4AAJiuP6SSA2cui/e1hy5omhPt3o/aasHQfIfCcVvwEoffONq7dy9VqFBBGDps9Bw54juJffTo0VS2bFkaPHgwmZnPFu4X72/M3mnqsDqtsNsxSYdz9HyuBwDkelNualrB8P1eW6eMbtsOtvBCsMbR+AHNqXmV4jTqpoZkOPZ6RAEANsAOFdq04mJqpsvnE0nof0RkWF2bNm1oypQpVLduXTp58qTwBnGo3LZt26hIEc9Y/WXLltHXX39NmzZtCmg/6enp4iWRnJxMRiF1lOSPv5mcEaF0DV0NPi1aE+D+DdjH639uN2Av1iAmOh/d174q/alQkEMv+jWrQCNvbGiocRSqa96Xh42NS2UDU6N5jkLshKCjAgAwFIgcr1hxzNmhOO2LBQ8knMZR7969nX83adJEGEtVq1al6dOne3iGLl26RPfeey99+eWXfkPv3Bk7dqwwvMJBbHQ+U3tZoiwdVne1I6vDvtFJ1K6CWygM6VyDShTKr9v2vR1RKLeUyzNlotvIRGIHAAAEgYglLVNK0jKz6XRyGlUtVYiMYOORC/TCb1toz+mUAH4VOULbocHgpG3nOSpevDjVqVOH9u3b5/Hd/v37RSGGG2+8UeQp8eu7776jP//8U/zN33tjxIgRlJSU5HwdPXqUjCL2aodSbjmbqZOiJo9EjdWfEwbX0bydp3XbtpmukVnI9bJEhe3+fKFXPc0nAfQmiI2+/prNc+TjBOGWBgCYjUAGVrWUy70+WkLXvrdIGC16DKq6t/Wer1YHaBhZrx/C1VmV+osWOwzzGUcpKSnCyClfvrzHd1zie+vWrSKkTnrddNNN1LVrV/F35cqVvW43Li6OihYt6vIyMhTJI6zOYne8N7sn3EUmRszYStlWzOa0KOHwHMn7+o92qUl73sjzNutJKHdVMGfJCJlgMbEDAIgAvMklvQuPHTqXKt5nbTlJRnA5w7XsN3BFi8ttULE6/cPquBw3e4I4lO7EiRP0+uuvU3R0NA0YMEB8P2jQIKpYsaIIi4uPj6dGjRp5eJoY9+XhRm45S9WwzFqQQc3N5M0AkS/elxjYiIjZ4UM7ej5XeAJXQz+cKIWphkKUhcuJahEq+usj7cSUA09Kc5eZRzQBACKAZfvOql7XpKJVN+wijh12ORCjjKNjx44JQ+jcuXNUpkwZ6tixI61atUr8zXDlunxBTsYYTnafvqTQUTJnKW81wsabMSc3Al+auZXsBB/bmFk7wt0MUxFuz5E+O1BeHEoCaTBN1kok+CzIoLCTVtVKinfJOAIAACN5/tcttum4X5HNA7jzZHJEGhWOEH9vBQNYd+No2rRpPr9ftGiRz++50p0ZSZc9IGav3KEm5yjLizVnosPQHD40hOy5ctc13kNX9cKOcyuFi8JxhszrDQAAYWXtofP00oytNKpfQ2pfM7ACXqHwl6yS63879MuJth4OshPWc9mY+KYId9nrUPAeVmexA7FJeFS4GNzR+EmX9b4EuhhfQWzSiEepb5Py1LtRAr12QwP9dwYAACERvGy+feJK2puYQnd/uTp8lWnt3T3ySji7hUYNpmKYUcMbRX6/fL/qMF1TPTecxRJhdSpyjmyHKBMe7kaYCz0mTA033q5xSKW85dsJfjPB7TvKd77WhHtaGtkcAACISLQwuuwypYjDHofhBJ4jDZC8K/KbQ+56tQLZKnKO7AYLJfuZAtYjTClHISmlYDyOdn6WAADArOglerXYrhXVgsMmBp0vYBwFgbuXxWGDG8ab58iKD24g5IPryAOjT4kVL4G8yRZsPgAA6M74+Xup36fLyK5okXagZRerc53cQmd641DKsw/g91bQmTCOgjAi+oxfSjd/vtxlmZnhUW4uw52RlVdEQrXnSEeDL9ydYj5ko9swtGtNY3doCfS9CErXmJeFFFYn26bD6Gp14X5wAABABePm7qHNx5LIrmgh07WMKPj2gdZkd6IMUn8wjgLk+MUrtOvUJZdcHGfOkZd7fNnes7T9RPgExJI9Z6j7uMX0vylrva6TlR15OUd8vYz2HNndExcpWLnCHsL7AACRhF4yT4vNsneNLDZw5lBaZjO1goIMOuUcSRw5l0r3fJ1bTeXQ233JjBOxvTl7B/2+6UREVqsz+viscDaNvuQJxeIpIrDCxQcABEV6VjYdu3CFapYpHO6mWAY4wYn2n7kc7iYABeA50gApJE0pBO3wefPf+F8uPUhnLqUrfmdn24gP7Z9tp8is3Ni0AtlxktmnutV2fl76fFfd5+ZR8vLkj84Xkq0CpQ4AkHPHxJXU7YPFNA9z35gOG3djwoJDMefIXmcZxpEG+Ao90zP8JulKZlCTmKZlZpsiBCcqAsOLOtVWP1ld+5qlKBzo2fHv3bi8iwitXLIg6Y2S0OaS11pd/9hodSfMXqoDACBHyq2Zvu5ouJsCgOE4HMb0MWqVNcYzC+NIA6ROlpF9bQ7XazrqP7pt4oqAfvfb+mNU79U5NH2tOgFu55wjo5l8f2sqV1R9CJkdQxrNMo1SbExUiJ6jvAN5qFMNqlOuMD3Xsy5Zgeh8EPsAAHOih4qwoSoNM46w7Tk+NtqQ/UBLaoAvAyIQL00g/LHpuHjfeORiQL979pfN4v3537aE33MU5tgkox/vYgVjAxL8wXgFzY5JbCOK0dBAKF4wP/037Foa2rWWqQshsPFWo0whVEwEAOgKy7r7J68JSh/YT+tFBg6bXTgUZNCxIAPn8Tz43TqyKscupNrac2T0wxzo/rxVELQy4ZhXylvOUSha2CxGXiCw8ebPgAMAgFDhir6Ldp8hs2C3fBigP/AcBYhS385ZytvtAZyz3bzJ/mp48Nt1uoZ2hb+DabzADMRb1rtxAoWDKJ2PX832r6tXVt+co5DD6oJpBwAA2J9Qoh6irk6ZkpSaqWmbgJkKMkSR2YFxpCNfLz2g27aNGIDn0R894WPo2bAcRRKBXLbyxQpQOHCYIOfo84EtdGxFbkGGUEC1OgCAEpANoXE2JZ06vL2Amo7+j7ZqNIGs3UK+wo0jAs4njCMdb5hD51K9rvv7xuP0lQ7GU1Z2DuVoGAund97LhIEtKVxEwgNu1Y6D3h2MUKvVBVOFEvcbAAD4lvPbjic7//7ft54T13O6Qq+PlgS0H7OJ3t4fL6VzKcrTp4RKwwpFSW8cCmfUbvoNxpGG+Ls35J2xp3/eRG/M3kkHzqRoahhd+94i6jN+qWbJ31k6GkfcwcwXxvJlxj/LjogfVeScI6PPe2pGtubzHAUD4t4BAEA9qelZHss+nr8n4KgWs3Xcd55MpvHz9+qy7UmDWmm6vW2jelIkAuNIQ/wZJEp2RnJaVpD78lzGniqO1WXBoZXHx45FAcKJnvNeWQG1OVdanqdZW04GPTeRNyLdyAUAgHCQlplDdiA9S5/jKF4gVtPtFVaYpN1sxqYewDgKkFBuCr3nrZF32LTaU1aOjoIozB3McDzgVuhUR0XCPEcirC7w3019sI14jzLh/fbZ3frmaQEAgB6y7sTFK4o6MtzTfRhB9/raFR8KlqaVigW0fk6IuswKlxXGkaFhddJ73pp63SNadcQybew5QphTBOccxeSj6xsEVgykbJE4al+rdNANfPPmxqQXnWqXpr5Nyuu2fQCAOiI9OiAY3py9U/W6wZ1d8+r6ohp7eoLRnd/9L3fQL5QoKUeQp7h66UJkRmAcaej98XdzSL+VW91adAKvH7eYLqZmuAgNrbxUmdn6eY7a1yyl27aB9050pM1zpATnHPGkqMESzFHc1rISbXrtevEebDgDAADYjSuZnnmh4ciDNhK9IgmCMc55gvqHO9dQvb7D7XOVkgVV/U5J/ZcvFk9mBMaRpje0Q9Vv5YaLFqNMexNT6KulB106nmoevCsZ2fTm7B2GG0cv9alHz1xfh8bd0YzCSSSF1V1TrSRtePV6+vq+1ppvO5BOvDlMI6JKJQpQfGw0taxawtDrWLxgfr8DF4XyR1OTSsVo68gedE/bKsHtCAAATB6VIfV/AikgNXPj8cDbY2Z7yiRtG9Gnvup1c9xOKOe42y0SB0OTAeII4QGUbh4u4x1qJ8uhMJoi35Yaz9GERfvoy6UHDQ+rq1i8oClCgAyvVuYwPob61haV6Mam5alVtZLCiFFTqKNOuSKqt39tnTJ0R6vKNHTqBo0LMujLoHbVKGz4uQR/PN6RapYpFBHx9gAAIBeJLjlHZF+k49SiH5JQNJ5e7ptr3EQbkNib49boUCKVzKrm4DkKkFBKZPMNtXzfWXru1y2kNXyDyb1Qam7W/WcuqyoPrjVmGWFIUyjxbDdi8kVRl7plnd4dFpz+3OeF4mLoZZWjSN/+7xqqUNycbnFvtKhSnPLH5Iq+YOVyKPLc37PJuk0yjEw94gkAABqgt5wzoxydtvYo/W/KWk2mXfni3pZ0Y9MKmlRiDdpz5FD/+ygL5OjBOAoQb9d/wqL9frv8fENxfXu9rGZXz5H/9dUYUHrmHGlN17plqEYAyX2nk9P85kTNeqIjaWvAmsN9Pqx7HZ/rFI4PIFQugJuYV+3TOEH8XbVUQVXbVDMQ9kKvegG0IW+DSk3vVs9/9aBaZQtTsJhQTwMAgG2NEbMMyLqzYFeiqkFqfxhe4c9hbCXmcADjKEC8WfnvzNnlP6zOQTRx8X6XZVpZze5bUTMaoeZ+PnI+lazCu7c1dY6eqGHp3rN+yz0XyB9N2obVkeYlONvWKGkZVzbnxdVLKEorXryO/n26s6rf1E3wP+N3tIaS7Ov7/edlvdyngTjvb98SeAU6fwMXCKcDAFgZRxhCy3xh5r67FQ2LHMWco+Awq7qDcRQgvu5jfwYJf382JUP7RhHRvsQUeui7dQF5jtTczhuOXAy6TWqrcmlJIA/omkPnLeHp8UXNMoWpUYXA5ijQmqgg1q1QPLcgglbb5zy25lWKk1FwdZ9pQ9rRXdcEXjBBizAKd2BQAQC0ZsW+szRpyX5dZJacULeflJrpd509py9Rtw8WkR0xOjQtx+16qS0gaCU7EMaRlgUZ/PxW6QZS06dZdeAcbT+RROlZ2XRcNlmanP92nKZdpy7J9uX/LrRJRUwnWvcPo3TodOohxHwlYAY7nhNQ/LAOclm+SYfKNnD+U+D7CSwkUAv8nVuYOQBYFzuNU9z91Wp66+9dIvwrEDQzplSeyykrDvluDxE9PW2TJiFsgDz6jny9A7nmVhjMQ7W6AAnlmVe6efzN+3Iy6QrdNWmV+LteQhFhAP0+tIPfdrw7Z5ff9uSEyTrSa/RAbFfDjfMDrPUjrIdMyBdEdZpwiaZg2mqWY9LqblAyWB+5tqZHyC0AAJgBvcPr5Wo7GDmbrULvBzKXkpFo0Scw2tZwuBtHIbTTrIYSPEeGTgIb+P6OXcjzFEmeIXkpcG9MX3fMtJOp6TUjshi90NxzpN32uG1F47WdDZuJDqKRmhYCCcT7onY9c8pLTVCSE70a5RapAAAAq8I6eNep5ID7FqFq7lgDylcDH/rZEXzemFmvHIwjLXOO/E4C6/m9v/A3PWM0w5UI2KiiPjkyWh9NrudI20eXCzzMfrIj/f1kJ202GOXbG+PtEms5WhPQpnSUhGYdgVJzTbjkuoSaw3iuZ12NWwUAAMqolaw/rz1KvT5aKkLYAiHUrki0n/LVZs510aJtRh9fjFufI5Tdm1VtwzgKEJ8GkN9JYBWWBXFXsZGlxQ2lp3H0Yu96igK1TJE43fbJx6PlIYmCDDo8uA0rFKMGFfxXYNPTc2S3xNFg51gIx7CV0nPHlRGV8HZYeidIAwBAoHw0b69495Yb7Y4kftWKM2+TmMfmi+yurLtOmTuss64FivK5G0cq+16dapfxWBaICjZiDieJyL6jgsDXDXDxSmbAnaJgvE1adYuysvXrYIWjw85yU8vAuiiLGBtalrHWG7W3RTBeICtcL0bpDo0xUOgDAIAenE/N0HbOHrfvxszaofgbf/LTrPMcMcGOc43p19BrzlXtckWotwah2s0qF1fVv1N7CP/rUE28B6PtrqtXlmY+1oGMwkLdKvPz2I8bfH6vNOjh7cGQiiXo+UjrOfgcDmeG1qPpenmOrFDkQC9lYoHTqTt3tKoc8ozhcBwBAIxCrbgJdtJ4tfrGW1U69zAvu+ueYgVi6VbZVCl6Fde6oUl5dWF1Yvf+2xCjMJKrZiC0ZplC9M39rXVLyVACxpGBoWirD5zzWKa0ucnLD1Ljkf/SlmMXvXaCuKx3qKip8BIs3qrw6dmp421ruX1/lQTNQqheOh6RCYVAdh9MU9Uaveq9UrK/yXiub1CO5j3TWZWCUHs/W+NOBQDYmWDlUKh6W6nT7boDMi0ODfon3sINzTYgG6VymRmAcWTgQ/zM9M2e21N4NEb9tYMuZ2TT879uUfw+NSObPlsYetnflLQs0guee8do26Js0Thtq9UJz1FUWO+dWU90pLdubuxzndKFA8/jkh9Wt/qhGUdpAZRIDSbnSKtrIIUIKHlujKZW2SLePUcqDtfEut4SvP322+K+evrpp53L0tLSaOjQoVSqVCkqXLgw3XrrrXT69GmX3x05coT69u1LBQsWpLJly9Jzzz1HWVn6yVFgPSwyphYQeh2SVrLdX1/dzPIymIgXPm1y743SQLeW+b2zn+zoc0CWy6RvO56s2f7McP10N45GjhyZW/VL9qpXr57X9b/88kvq1KkTlShRQry6d+9Oa9asIbOg9UXie9pn51JhhxsOX9Bk37tP500aawfFERcTren2tK9VFzjsRr67TRWvYQN8Pvs1q0B3tMpzsRtNsh8j+7EuNYO6/n0aJ9A11UtSnXKFVRnG/q7WtCFt6a/HO9JtsnAEs2DHDpVZWbt2LX3xxRfUpEkTl+XDhg2jv/76i3755RdavHgxnThxgm655Rbn99nZ2cIwysjIoBUrVtC3335LU6ZModdeey0MRwGAcYz8awdduOw9n4jDunaeTA56Ynn5z/QQhWYuYBNM06LcJn/X+/AaVijmoW/def3P7UHpuQ61SlPEeo4aNmxIJ0+edL6WLVvmdd1FixbRgAEDaOHChbRy5UqqXLky9ejRg44f9z+3jxFo/ZD9u/0U1Xt1jgilM3sJbiug6akxUc6Rr3ZwSMG7tzVV/M6IO8XXKdoysgc9cV1tVeu68/nAljT94XaqftO6Wkm/1yo+NpoaVyrmMlqpd0ig6m2H3QyPDFJSUmjgwIFiEI4H3ySSkpLo66+/pnHjxtF1111HLVu2pMmTJwsjaNWq3Em4//vvP9qxYwf98MMP1KxZM+rduzeNGTOGPvvsM2EwAWBnJi7xHq3yxuyd1PvjpcFvPNyKKowEm94QFcawukeuzRvwDAa5Lr23XVWKWOMoJiaGEhISnK/Spb1bij/++CM99thjQvmwh+mrr76inJwcmj9/PpkBrW/Bzxftd4bSqd1fmOZu1QS97Tqtq9VZvdPqrWKN/LhCPUYuz3lT0wqK33lMemsWazMAShfOL95H9Kmv2z4CPS0YHwkODptj7w9HJMhZv349ZWZmuixn/VOlShUxSMfwe+PGjalcuXLOdXr27EnJycm0fbv/UVMArExmlneh800Ag7uB6G1HAPLw/OUMryXEzSwutSimoGf+uBKF4mLIGwVio6mcgmfJW19DTTGNcFxAQ4yjvXv3UoUKFahGjRpi1I7jttWSmpoqlFbJkiXJDOjtnnUPsVPa3ZHzqWR2zOzGDiThUcu+fFxM8I9bZhBl1z+7u4WqYgscllelZEEacE2VoNrG7v3xA5rrVgAh3HfSy33r04ZXr/dqAAJrMG3aNNqwYQONHTvW47tTp05R/vz5qXhx19K1bAjxd9I6csNI+l76zhvp6enCgJK/gH2x+oBaOPDaXVAp/Hm1FmPmUoe3F9BFDcqJG4kWhk0wBtaT3fIiOrSkfLF46tesovKXUcoesHduzc2rfqN/I+VtFo8n2xlHbdq0EXHZc+bMoQkTJtDBgwdFTtGlS+ryXV544QVhWLmP9IVLAend53/2F8+iDXZCd8eBhtdn/eELmqq5JpW0L0Mpb9+7t7nmUDSu6BpC5vK7KNdRoMXPdaGxt/gu/KAFZnMcqenI8DolC+XXtx2Beo7CbjJai6NHj9JTTz0lIhPi441VtGyMFStWzPniUHEAQB4OFcLwqMpB4QNnL5OVCCZNwl2vK4XV+dMpajw2Dh9NmzCwBTXVqE9zZ+sqtGN0T7qnbV6IXf3yRWnqQ22oe/1yXtMGLG0ccVz27bffLpJfOQTh77//posXL9L06dNVVRTi0b6ZM2f6VWhGKSC9uySzt5x0/r3r1CXbdYKs5FA6cyld0zhlLSvf5W0z7+9AqrC5y0X3tul1nfQcVTWb4RUI3vOgHJZ/jswAh80lJiZSixYtRJg3v7jowvjx48Xf7AHivCHWTXK4Wh2HgjP87l69TvosraPEiBEjRE6T9GJDDQCrEY6+iLTHk0lXqNO7C72ut+5QXpGq8ykZlpKXOUFMDRWlgYEV6E8Siub2wdlYYXo3Lk9f3NvKf+PkX0V57wcUzO8Zqte+Zmn66r5WVLF4AbJ9KW8OW6hTpw7t27fP53rvv/++MI44Cda9qlA4FZDRD5mZH2pfOMIUXqDl6cofk8/SIRK+jAUeqWGBc3/7aoa2w8oGjJ6EelpwXn3TrVs32rp1K23atMn5atWqlQjzlv6OjY11yW3dvXu3CAFv166d+MzvvA02siTmzp1LRYsWpQYNGnjdd1xcnFhH/gIAqA/D33zUddDCnd82HHP+/eB36xS3Z1YRqUWBrSwDEtH/fKIDfXRnM3qiWy2DihSFF+9ZVTpWC9q/fz/de++9Xtd599136c0336R///1XKC01sALil94YXSnOoraRLXKdYqONn6tJS3ydCp5he9kLXVWF3YWKa/GH0I6jXkIR4VH1tx85pXyExKk5TiPugcDD6kAgFClShBo1co1nL1SokJjTSFo+ePBgeuaZZ0R+KxswTzzxhDCI2rZtK77nqqlsBLHuYh3FeUavvPKKKPJghO4BwK54k2cp6VmUmhH4PGIPTFlLk+9v7Xf7ZsBbpbnqpQvRQS8hgpK+4FD9LceSqFOtMrp7C8sWiaf+zSuqmtTVWz8sEDUX7r6X7p6j4cOHi/CFQ4cOibKoN998M0VHR4ty3cygQYOE10finXfeoVdffZW++eYbqlatmlBA/GKjygwY7zky82Ody81uD4xdYM+RkfC8PkbiK8xPt7C6IASew01hGLFPo3ExIK3QYBvy4Ycf0g033CAmf+3cubMIlZsxY4bze9Zbs2bNEu9sNN1zzz1Cf40ePTqs7QYgXOw+dYk++G93yNvxpW8+mrc34O0t2n2GDp9LtUQ/ypvT56U+9Wnkjd490szvj3WgnaN7UbGCblVhjSIqwNUtpNt09xwdO3ZMGELnzp2jMmXKUMeOHcW8Efw3w2EL+fLldUK5aAPHft92220u23n99dfFhLJ2jrvNyPIMPjXvI51HrbKek3SGSxZpud/csDrjePvWJvT3Vu9Vr5SwQtifa1hdaO1V+vntVyd19bbpUO8JIwS6Xm0H5HNOPTmc18pzFvHLG1WrVhV5swBEGkq6pudHS0LbZpT/SWC3n0iiFlVcq0iqQb5NM4tRb9FI8bH56LZWlcUEvJ7knqV8+aKoQP7osPVloxTuCdaXdtBbuhtHXFAhEAXFHiZTo+NF/3aFyY89QMIxSKDl5YmNzmfYSAcnOXrMCRQiZhmk0bIZSteDS66774cN9n2J2nibjTiNUYHuzw7aBwA7YhK5qzXhKg7Fok4LcWdWr4WvVI3CPuYTCpWmlQM3ON0J9JRGmSyc3VQFGayOnuJh50mF8uMW6APp4bKe/EBevHC4iM1npOdI+3Nolv6zXClJhkwgNK5Y1OfvQxGiVhDSAAAQCgt3J1LX9xfR+sPnyUwcu3CFdpxI1kVZnZRPCGsSXRhIzpHedKlTRpTjnv/stV7XyedH+UUFOOdSILo03FExMI5MX5DBxE+1jnStW5YKBuEu1vLy8IPs/jBPurcl6YFZDBlfvNi7XsjbCMbQuL99dXq5T33656lOygmgUnlQLxsP9dQaIqRhgAEAdOKByWtFcv+AL1eT2egzfqlrWF2UgucoiO2+PWeX8+/ZW0+6GksmIpgJXLUYsGN9yeW4a5Yp7HMdXyh9r9U8UwnFjJ/4VQ6MIxt2Yo2Eq54lFDO+Br03ujcoq+n23DvGPRrqUzQh2NuqY+3Shnk8gnXxR2mQ+/VQ5xpiUjjlY4rSfJ9yVMyVp3FBBv/r39+hOpUrigppAIDQ8prN1q/Sqo+Vlpnt8vlyhutnsxAmx5Guus8RwkDj94OvoesblKM3+rtWFzUaGEcBYvR9PPyXLWRWxvRrSGtf7i5KXutBMFvlScPC3ggFnuxWW1VoYoWroyVq44FvaFKezI68sx+qoeHTc+Rln77CPtUIa6NLeavpHJQslJ9Wjeima5sAACAcFfC0iJ4Jd1iWWrKvCnw2CNRi1JHlCyKsLlQ61S5DXw5qReWuTjobMfMcWR09S0Iqbfn8Zc/Zns1CdL58Xstdi0lgFZ8ch+4JlDXLFKL9Z7Rx7YbSMa5RuhB9dFczEVN9Z+vKqn4zbUg7+mH1Yfpfh+p+1+U5f8JRjjsUQlVYygUZtN+P+9b0JspGCcYAABAIcgPoipvHR6uCDGZFCqu7o1VlmrvjtIa5sqHrh3x+RjMDLshgIZUFz1GA2PgZtU0+lJadxkC3VLdcEeffj3apSU0qFae7rqnit03SmaxSqqCY3yDc8bZKVzbYqy0/9lAvTZQPQ8hrOezQdmmQ5yhKuQStOR8xAIABbD2WROP+2+0RImY3IlnOSZ4jM9oN+fw0KthByLIWCAmH5yhAzDyZmN3OU7DCIpxCplejBNp9OjcsIJAzoMdtpXmn3q2R0W6Sc0TvevTdysN0XMfEV+V5FTzXq1yygPM6hDwCR/oTFeKzY0bFCgAIjRs/XSbeWSI826Mu2ZXtXLFOY6zipZDEvWy6T9OQz99JVDE/X6OKRWnbcdfrW7ZIPE19sA0V1LFUeaiY8HKYG9hGBiYSRoVXKPJofkheqADOj8OC9+InA5q7fH742pq0/MXrqGJx7wU69JgENm/uhCjaNqonbX6tB8XHBjcxntkmgQUAWAs9HuWdJ/0P9NgVVnO/rj9q+76aNy/Mzc0rivfW1UqYz3MU5X8bpQrFKa7fvlZpaqbBXEt6AePI5g+cnmRl+6t8E2JHWOPRjmBKg0eFsO9Awg6t6JH0ZQTphXJBhiiXinrFCrpOphvqqTXGcyS7b6x3KwAAImDwhHX+tuNJQZWfDoWFu89QpF7jN29uRB/e2ZS+GtTa8GITUUEWZJD3fZ7u7rsYlVmBcRQgeooEq3WQs7KvxsqaRXL74cGO1al04fwB/SbQQ4uWPVEWu5yGEOo9rvUksGow5Pb2mi+FmwiAcMOFkd6ds0vMFRQOzKJhn/9tC93wyTL6dOE+43YaISLQWz+qYP4Yurl5JZdBP6PCwaODmOfInaIFZO02zZ3sHxhHfriYmkH/m7KW/t56UvdJYK0mAzL8eI6uq1dWlcdmeI86ZFbvRqAPs7y6S7ivZyGN43kdGhgNoT4/SnHZegjcqqUKhq2UNwDAXAz/ZTN9vmg/3XQ1ByhUpq89SjM2HCM92Hv6EqWkZ2m+3cnLD9GMDcfF34YaR0FitYEl7jp8cHtTMhP5/FgIUTbWczCO/PDh3D20YFciPfbjBvEZ3gBPz5E3utcvSz8PaUtLn+/qc72hXWvRgmev9VgerEdK/runPFy6gW0z0Ca4hNUFknOkct3ShdVXeeG5cILGrUEc76zFve83EtMPtcvmVQOUiPEzz1Yw3qr/hnU2NudI9jdkDADmYvWBc+L9Upqr0XEuJZ2OnEsNaFsXLmcID8wz0zdTepa6KnRqRdC6Q+fp+g+XULcPFpGuOMxv5Jh5clVvfYdbW1ay1jxHUWRbzFsqwiScT810W2KxJ05HMn30dLmDx53KNjVKic+1yhamfYkp1LNhgse6vF6NMoUVlmufRKj3wxwdbM6RynWrlCxAReNj6MDZy9TXxwSw3a567bRiygPX0K/rQx/pDNVzdG+7qpSclikmiluy5wzN2HiMHu5cw2M9+V5e6F0v4P3ExeR5Ow2JqrOzlgHAJuWW3Wn5xjzxvuZl9RMyX87IM7CyNe7Bz9l2SryfTk4nu3hlglUZ+8+kkJWIMlBf3Nu2qib7ifLSajsM8ME4CrCjredFt9oNlZmTaxypeUynDWlLC3cl0g1NKuhfytvbD4MQKKFMcsaTtOpx7X97tD2tPXSeumpsABkRohdqZyA2Oh893T03DLNl1RI07Hr/IZkD26hTBN4w3HMk63g81KkGTV93zFmxyBsWEx0AWAp/YmtXhFWTy/QTNWIGrNafMnKA7PZWlTTJOfKGPLfbatdBAsZRgDfHxqMXw9YWs5GZ5f2ud3+mOBzs9laV9W+UnxyUgGNkFX7xz1OdRB7ayaQ0j+947p85T3eiQ2cvU8uqJX1ue9K9LWnI9+sDbBFRiUL5qYeCB06OEfIomFwfPXP29MIYz1He3/JTVLtcEdo5uhfFx/qOgNZ6BBoAkIeW1dmCEYFqZa0dHdCRItm0vnZabC8qyFLegzvWoJ2nLl2NFMq7gla6PZFzFECCPbtpJy05ENb2mIVShfLTkKvhTA0rFPX4Xos+sBYjKfItNChfxNnmUKhfvij1aFBO8Ts2juolFKVejbyHvEnIDRytbQY9Kh+q3WaXumXEezmFWbCNLgGrBYYUZPChNgrkj/b7LFjQ5gTAkmF1icmeg2KOIPVWOKp3dXlvIc3acsLw/YIQJ1zVELX3Xb4gm8Q667O7W9BNTStYNnwcxlEAnqO+45dSpHNLi4p04K0+tPbl7pRQLF4s43yhmY+1d1mvuNtcM8bOc6S8nEcxBnesTlMfaqN6/6EUZNCDcAoXtdXqXu5bn8b0b0R/DO2oOnY/XLSu5tu7xxSND/1eDshzFMTvreiRA8AqyB+vh39Yr9nzpzZ3R0uxf+hcKj0+daPffOJxc/eQGbDaFCfBIl1jHnzNH52PWlQJbdLXYE4bh+x3vTq4ycT4KVcX8CSwZB0QVueHaFklrLTMEEtt2YBKJQq6eNMkmrs9yP5yJNRQs0xhOnf5fMC/6924PG0+luRRxlsyLBpWKKZqO7y6/Ej/16G6bsaR1cqO+oLnZfCW8BlqtTqtefjaGmLi2NGzdnh8xwbe0fOp1KSSuvslnMA4AsAYNh7RLrRe7WOrVq1oNXj2/crDNH7+XjIDkSLZpG7VrCc6UlZOjktRIHf0GiPlPN5Jg1pR7Zf/EZ9L+pkXUo0HitMAOOc8LiafYt/RrMBzpFNCml2FgJqzwYUIYuSzoaqkRulC4r1OudzKdR/d1UzV766pVlK4cOWTvXI+z5+Pd1BcX+0lZUNHrmxuU1FmM4jDFmjdt3U3Vs2Cv9wZrbjjan6bP8OGFdD/OlZXLKLBBt5LfeobU5DBJeco8Jvham0UACKahbsTaeLi/cZ7G2S7i7KBzrdapTd7EOUMzfdlGOl9b8kHeKuVyu2TeUOtamxbo5Rp+yTegOfID3yjAgpsZuYgO5PfDb6Gvl1xiO6/6qGpoHIC1+mPtHP5zIaZr4IFar077p4jNd6dYI/d35abVi5Om49epDv8VJmZ90xnWrT7jCh5HQpaK+3Xb2xAs7ecdDFE9OTaOmVo4fAuVKF4buinWuSzeRuJfAQOYXUABMcDk9c682C53L9RBOv5V2vEGZ2bZKbUEDOLNs49/m/HaU22FUhXM9DrI02lorbPO+Ox9pSZleN3rkQT3SaaA+PIRElyVkCNoArWe8Ihey/3beCyrF+zCvTHpuCTR5WMFbVXNJico6A9jX7O67SH2tKe05f8ekJqlS0iXnrDMdEscNXyQIfq4mUk1a96Iq1AqGIGxhEAeShVEjUjWj+1cjGy7XhS0FEc4SgUYUU4BK3ai7M12ZbWEQpyw5vziNQaR0wLlV4eKxVYCBSE1enU0Q+GbJvExmhpUH50p7rQukAIJH5b/vCrMwz1ERZc/YW9R2EtyCA7/i0je1B8bOiuf+BJMHaOBYsAAqAfRkfVOYJbV/XvVIp9+eZu+GQZvThjq/qGyXdnoj5vpIi2gDxHARqvlzOyA2+QCkx0m2gOjCM/GJlAZoWCDw6DjSM9jIFAwuoCpXmV4rYtyCBvoV0NoyhT7DfweyFSKjoBYEaCfvzUFmQIcvO/rj9GlscA2VbABPpMTb9k2NUJ0Ef3axjQaft57VFd+htRNraOEFZnooIMV3Sy7o0WVJGYp/Xs9XWoV6MEquongdEb6Nuag3AJe/kzU6ZwYHlSZiyRDkA4kTp/PBk35xG6507wYMLD368Xkyd/dV+rkAfhgreNtH1utRJfkabBuVDQlUzt+l9F4mPoUloWac1T3WuLuRo5kiQQ9JokPMrG1hE8R36IMbCjn55lHuPo5T71FZc7TGZQBjOirtpz5Gu7bp+55GXtcsHn+qBraw7CFWvPSmbusM6ijGuxIOYIs0lELgCaceLiFery/iJqMWaux3dJVzJFIv38XYl0JiU9ZL2y9lDelBN/bj5Bd0xcqapDypvZdSqZ3pmzi5LTMsksmKnTm5FtTu3IRYa88cdQ5Uq5vlDbL1FrGFkhGsXMwDgyUVhdIAnuelM4XtmpqGaA2kRyVZFY2dxVaoRVQtF4YST7uj6hDtwjLAqwcd2oYnBzKqEgAwB58OOw5Zj3+YgCGUg/mXTFY9kvbuFqk5YccPm85tB52nDkgt9tZ+U4qNdHS2nCov305qydljBWjGbnyWQyIzwnkJapBVpfYqiE0EBYnYm8IDxZllnw9mCpGY0wU1hdl7plxXttmWGjVtFIqy19oasYBbRrno1aIsGAs2ofBMYRiDTG/r2Tlu49S7892j7gMKNAGDxlncey53/dQnX9RAqo8RyN/Gu78+9NRzWYXNZA+WUnfeC4Ol8iG7Xh0iNaV0a2z9UJD/AcmchzZFZZc1fr3Ak11bbRTOXPyxSJo60je9A/T3XyuR5PHOstxCo2Op/uhpFJL33EYaJbNyBQrQ5EGl8sOUA7TibTzI3Hdd0P70OJfp8tD3mAked+UzPAoYdYSvORY6NGDtpN5nw5qFVY929V3WNXYBz5gOOS3/t3t2H7yzGZtFn6fFf69n/X0Js3NzatQamGIvGxfud6qFKqYEjCymFTwxhYA3iOQKTibQoMsz4S3trlq6iKHh3nu79c5X1/KsyxLJslOirlegbblQkmd1XrbpNZ73+rAOPIB2Nm7dB0eyN9JPAxZrKNeHSrcsmCdG2dMi4PrbpS3mQZqpYqSDc1rSAqzYVzJMdElz6iserkh1CEIGIx6ZC7txB0h46Do4HIrw1H8sL4zl/OoINnL+dtJyp8FdDMhLGHqN99bGSfbNRN/suMWwEYRz7YcUK7RMAmlYpRx9plLDn6G+hEqEZW+AsVDqcbP6C5Ym5ZQB3l0CsykJkwWXMivZ/llRG964n3twL07gJgZ1h8hV2EeQur8yJcfXqOSF+4ol/X9xfR8YuexSd8FZMAWuYc6Wecu+dZazkIWKlEAZfPvRUGmq0IjCODYLnH1c6euT53Ei8rGUeBFmQwU86RrzKcnWqXpttb5eVTuZMPT4cLFrg9I46Hr61Je97oTe1qlgp3UwAwjWDyJ6vkBorR3mLvniMKO1uPJaleN9ukJbatqis1L8hg0OVpVMGtwqr5u3+qQPfPB3r08Z+4rpambuoSBWNFaJjWeH2wLFaQwRsPdKhO3w9u47PQgpFKE2oGBEv+GIhxAMyGN5memp6tW5ha6Ko3tw1REeY5qlJS2z5UMNdBz26TkT2yfBbo/6kBWtVgfJWRtoLnyNdT1rFWafE+qF1VTXdZLyH4yVXVwjOoN6tcnJpWLh6WggxWAJPKAQCAOryp8xs/Xaa43Ge1OpXKSGkTwRhd6qrV2UMf9GqYQJ/d3SLczbCNURFF9gDGkRfOXEqn7RrmHMl58+ZGistPXEwLeFtaiKf4WG1ugykPtKaVI66j9leNJK3464mO9FiXmqQnrHxmPtaefn+sfVC/t1nKUcRi5GSLT3WrLd5f7lPfsH0CECn4kqmOMAwmcSjfpwv2el3fl+gJRSqtP+x/MlrPtvjf45QVh8gOTLy3pSg+5Y/8firemg2X0FEDLZYomxh5ul/tkSNHipMlf9Wrl5tE7I1ffvlFrBMfH0+NGzemv//+m4zkXEo6tX5znm7bH9hG2bOyeM8ZCgc/D2mnyXa4XHb5Yq7JeVrA8wyVKKj/BLnS/SlRIIC5jUKdEA9emcjj6e61adWIbvRQ5xrhbgoAlkVJcr40cyvN2X7K+28c/mXvvsRLdDE1g7Ri1YHz9P5/e3QN41bql+pVVW7Cov0USaHLH97ZTNd9aD0FilEDrg6358cuHkVDTOGGDRvSyZMnna9ly5TdysyKFStowIABNHjwYNq4cSP1799fvLZt20ZGcTIpcA9OuDq/WtyHBWWzi7evWYoqlyxA/ZtXtFWp40B459bGYvbz1/yUXtcSs8kTO81+HghG3t1siCcUizdwjwBEDn9tPqFOHzuUDaPu45ZQs9FzDZl0lfE54G6QYJLEvv21fGBlqT8Z0NxjXifpXEnpBKGi9Tl3GNRvc7g9P5nZJqgsYhXjKCYmhhISEpyv0qW930wff/wx9erVi5577jmqX78+jRkzhlq0aEGffvopGYXcWDA7WnRi5d6SN/o3oiXPdaXCcTFkJoz0rNzZugr9O6wzVSqhfaELb1jBFrFCG0PFJhEBAABfelL2cbJCeNiK/ec02Kfr56IFPCcZlRMu0ZOl1JmFHBTc174a7RrTi3o2TKBML9X5vh98jSb7skvOUZnCcWQHDDGO9u7dSxUqVKAaNWrQwIED6ciRI17XXblyJXXv3t1lWc+ePcVyoyhgJeNIg224P5N2iRnVEx+6FlgY3PkA2A/3yDKHW3jYvsQU1/U1CEVz34I/tRqK3r2cnhX0vIw/rcnrj0H1eyJVtFU0Ir1cNzNUq3Ppo+h4XR0K6RV2QHf3QJs2bWjKlClUt25dEVI3atQo6tSpkwiTK1LEswrZqVOnqFy5ci7L+DMv90V6erp4SSQnB19MoWCs/9MSGx1FtcoWoeqlc70Lf2/13T4zIx+x8CegwyU87e61sMLhWaGNAIDIQo1uyPUcRXnNi0i6kunyORxVqn0XZPCteG/4ZBkdPHtZMU92wJerfP72wNnLzr+l02J3fRsMmTrfFFF6TgKr7aZdsOu9ortx1Lt3b+ffTZo0EcZS1apVafr06SKvSCvGjh0rDC8tiM/v3/LliRf5ppCS6Kq9ODtsN5D8xl/2Qlfq+M7CgH4vzwM0a66JOVulZbU6sx9hZACvKQDmg/N1Plmwl7rVL0ctqpQI3XPk9tk9F16LpHJ3me5Pxvs0jvyIJTaMmCt+8prUooXnzOyMH9Ccutcvq3p9b54jrYiEfG4rYbj/q3jx4lSnTh3at2+f4veck3T69GmXZfyZl/tixIgRlJSU5HwdPXo06DaqKdnInSitq4sEhcO1QxdMngweytBpUTVwhQ0AAMA/Xyw+QJ8t3E+3fL7C4zs14xkeZbX95HtoMVblvgl/2zx6/grtOX1J8TujR/6zbTRYN6a/8tQpNzWtQAXzq/cPFI33nTMW6iCbnmF1Hve3psPNDrIjhhtHKSkptH//fipfvrzi9+3ataP58+e7LJs7d65Y7ou4uDgqWrSoyytSRo+1bK1Zj93MsnrakLZiAlm7Hp+V2ggAsB97EpWNBonp64665M4oya5LaZnOvBx3L45751GrcsSTlx+kPzYdp23Hk+i2if7zpnt8uMTrd9xmzo+au8N18FgPtPAclS6c3xSTqxaO0yaH/KZmFegWL1V83TFnLwqYKqxu+PDhdOONN4pQuhMnTtDrr79O0dHRolw3M2jQIKpYsaIIi2Oeeuopuvbaa+mDDz6gvn370rRp02jdunU0adIkshN/DO1A/T5bHvJ2HBo8iYHYQ3joPWlboxRFAkXizVXBUA9wfwNgLa5kZNNrf2z3uQ7bOjd+sowOnUulqQ+1ocpuERbuOlCLqLKdJ5Pp3Tm7Sct5kt6Zs0v8fXBsH9pxMpmqlSpEhTSsLOvQ8Ph5fsK+TcrT0KlkC/h4xt3ZjGZsPO533Zjo8GsSjGWGhu69nWPHjglD6Ny5c1SmTBnq2LEjrVq1SvzNcOW6fPnyHFjt27enqVOn0iuvvEIvvfQS1a5dm37//Xdq1EjZNWpVmoboabBjCchgeKVvfbIDZpsEVqk1t7eqREv2nKFOdXKfXTsSwY8SAKbF12OZkeU/F4Q9QWwYMQt3JdKgdtVct69DzpGWhtGiPWeoeMG8sK75OxPpwe/Wib+nPtiGtEaL47d6v2RE73pB/7Z4Af0nrfeL7BrqmQHikN0qaj1rVkB344g9P75YtGiRx7Lbb79dvOyEUQUZ7IqS8XBX68r0YKcaZAesELIWFxNNkwa1CnczAADAiRrRKc+hKVc03kPeRrv1Hs1WkODMpXT6culB5+eZm/K8F3d/tTro7b71905KvOQ66f3IP7fTj6u9hyhGgm4deWMDur9D9aD217uR7/x4o3AYlGfukP39Yp/gDUqzYY+C5BEMxyFHGRlWh1LemnJfu6ri/fle9hEq1iYShhoAMD8/rj5Mnd9dSIdkpaaD1Q27TublLJUuHOfXM2J2dZPtZULSQJm05IDHNCRTFCbFDQZZQFBYCabvEKdQEj0QzOA0C0eRqLJF4skumOT2tT96Clt39/UnA5pT9dKFqErJgpYuwhAJjLypIW189Xq6voHr3F4gPOBRACAPrp52MTUjLPt+eeY2OnI+lV79Y5vP9dRUVrvvmzUuz7i/SnLsqQkXKelZ1OPDxc78IiXmbNdnXsXUDG1KgZupCm44DF2lW/K/YZ2df9cuW9jje63PVpc6ZejLQa1oyXNd0ccLAhhHXhh1U0MyI7Of7Oj3wb+xaQVaOLwL1UvwnGTXH1Z6hMLpTbr2at6NmrLvvmChVaKQCeKTfdCpdmmKFKx0/wOgJ7tOJYvqaa3emBfWdmRm5/js3GXn+M85ks//s/d0iggnk+PuSfp+1WEKF9PWHKE9p1NEZTqjGf7LZs22ZZb+uNL8UnoWF/J23HXKFfG5TomC2vYD+JnhQdcqpQrqqtcalA++MrSZsX/5qSAJxrBgapUtTNVKFaR5OxNJD5RGY7wpjv7NK9J/Gpf9NMtoULjpVr+sqHpUu2xw94mV+Hxg+MuxAgCMZdnes+I9y2T5N+4EOjfnpwv3mTps+43ZroabFZgwsAU9+uMGVQUZWlUtQesOXzCoZZ4DyNxWfyFnIU/qHqC/6v721fSdN1PHTT9+XS06eiGVrqunfkJdKwDPkRfcEzTVUqF4AcPHn6N8JAa2r2mPMtP+Zhc3GjZI29csTWWKxJHdKRLA5HdWxyyjnQAAdQNyWlRW23j0ImVdtbLMpmusQKOKxVTL0lbVSmq236JBeIB6Ny4vinJoadzIB9M71S4TcKW+Z3rUIasSHxtNH9/VnPo1s0+lOgaeI42NI71xf+ZYjnt7DrkD37hiMVqx/5zPbRYvYP7Or5K+Mlv5awAAsAvB5Cl8s+wglS4SRzc1rUBGka2BZ+vV37fRvtOXqEvdsrThiHFeDbugdKt4u3uuqV6CJi4m4zCgm/DTQ23F/Ec8WHpD4/LCCzS8Rx0av2CfqlLzRXUegDRnb9bcwDgyyDjSajRKUQgF2dTbW1aiUf0aBnSsjSt5jhCFCwzw6QfOLQAgEPYlptDoWTvE31oaR6zf3DXU7C0nNTWOmG9XHhYvEDhKnhL3ZcO616GGFYpS17r2CL8qXyzP+8R5w4M7upb+fvy62sKrohQmyZMQc14ZMC8Iq7OY50jJe+LLhStXG5wL1b1+nmAqHB9DBfOrs4/nDutMH97ZlHqEqaoa+urACJBTB0Bw6FXVTmmgZujUDZqG1YHgefjaGop9EPdFTSoVo+4NymlWOU1t0SytI0y4KNbPQ9pSWT+heUr35rQhbalv4/I09pbGZCSoVhc4MI68EBNCkX4970P3zpsIq/Ox/oBrqoj3LnXL0IJnu4jSjhIxARiAtcsVoZubVwrbQwb9ZyyRKksj9bgBMBMH/cxtJEcrzxEIjuE96irKTclgalujJJUqlJ/a1NAu16hdjVJ0X/tqqvojWvcdGlYoRm1qqMvldr8129YoRZ8NbKHKsNIS6LXAgXHkhRArNKviyetqaXKT39O2qlMIucPzHW0b1ZMm399axMHKhYmu1VEMACpRPyLVGIUSsS9jx46l1q1bU5EiRahs2bLUv39/2r17t8s6aWlpNHToUCpVqhQVLlyYbr31Vjp92rXi55EjR6hv375UsGBBsZ3nnnuOsrKyDD4ae9Pv02WuYXU+nksYR+ElOor7FZ7Lpb7Gjw+2pVUvdVMdpaIGrhSrFkeQBpAWNKtcnMwA1FrgwDjyQnQInqNiKgscDLu+TshzyPCDf1vLSvTPU53o2/9do7hO4bgYxRGWDjU9943OIQDAjixevFgYPqtWraK5c+dSZmYm9ejRgy5fzvNSDBs2jP766y/65ZdfxPonTpygW265xfl9dna2MIwyMjJoxYoV9O2339KUKVPotddeIyuz8cgFevufXXRFNglooKpAS92RnKbe2DR7qXG7w4OsimF1shSFWI1Hm6X+TLXShZzLVrx4XcjbXfDstTTlgdaaGTXsKfrm/la0aHgXTbYHjAMFGXyMhgTLC73q0a/rj6l6wCuVKBjQtqO8bKd+ABNxrRxxHe1PvEwdrxpm8lC9QEtQGgUq0wEjQM6RfZkzZ47LZzZq2POzfv166ty5MyUlJdHXX39NU6dOpeuuy+1oTZ48merXry8MqrZt29J///1HO3bsoHnz5lG5cuWoWbNmNGbMGHrhhRdo5MiRlD+/uSd09sbNn68Q7xxM8Hyven4nh00oGk/F/UxayUWIPlmwTyThd6sffK6qP5WUA+PInAUZVNhDH93ZjP7bcYquq1cuqAloPx3QXBj1D3aqLqZR2fjq9TRxyX76YvGBoKIgapQpLF5awscGrAc8R16Ijg6+k8TlHF/pW5/0wEMGBaEXyhcr4DSMmPwx+eiWFhWpZ8NyVKkEz9NkPrpdFTByr1ykhn4BHYFtFDGwMcSULJkbjsxGEnuTunfv7lynXr16VKVKFVq5cqX4zO+NGzcWhpFEz549KTk5mbZv3664n/T0dPG9/GVW9py+5NMo2XY8iXp9tJTavDVf4ddRLobRoj1naNzcPTT423UBteF0cprL5yPnU32unw1FEHaUIvTVDLRWKVWQPh/YUkS/fD/4Gpr3TOeA9lu5ZEGRw9O8Sgln1bgbm7hWSsTAKlFRC0zXYjZgHOngOWLUx9ea48Edd0cz+uLeVqatasIlxOc9cy0te6FruJsSEXS7WtVQXq4UALuQk5NDTz/9NHXo0IEaNWoklp06dUp4fooXdw2pYUOIv5PWkRtG0vfSd95ynYoVK+Z8Va5cmazKkr1nxHu6n7lb2JlzOsnVyGH2JV6iju8soGlrjih+9+bsHWLOITlHz1+hFFmY3dmUdJfvEVYXPiqKSe+VPe6B9iR48tRaZfMmU9Wq0rDcdo6Pjcwur5b5XpECzphOpbzZE7P56EX6ed1Rn+sFPujl2q4B11hX0QZKrbLauruBd6qWKkRrXuoWcSNO5hwaAFrDuUfbtm2jZcvyEv/1YsSIEfTMM884P7PnyKoGktqwU/YcyT0HWdk5tPV4kpgH6diFK/TijK1019VKqpfSMkVYH8+T5I2TMkOr1RvzvM55BIylcsmrxpGCzaFmoDUYefvbo+19fu/usZJ3sVpV1a5inlYUjTe+Gw5vmn8i04w2wDjiyb/eua2J87NWnn/5c88T7b2kU/ieFcADri9cbpTvYwDsxOOPP06zZs2ihQsXUqVKlZzLExISRKGFixcvuqzP1er4O2kd9+p10mdpHXfi4uKoaNGiLi+rolYtCmeObN0HpqwVBtDGI67nlpm25qhPw4gxaUBDRNOncYKIOGHUzHMkh/PQShbKTw0qeD4LL/auR7HRUWKSendG92tILavmhtAFco9K8wuNu6MpmQWp6IM0SKAnPFgBAgOeozBPAlsgf/Cdz+sblKO4mAjuvOJ5BwAE0EF44oknaObMmbRo0SKqXt11RvuWLVtSbGwszZ8/X5TwZrjUN5fubteunfjM72+++SYlJiaKYg4MV75jg6dBgwZkdfz1oXzlkci/4oEr+ZpL9571+ruMbN8hev72C4zl2evr0GNda7n0kZS6Sz0bKg8WMH893lHkiilVsXvk2pr0QIdqlJaRQ7+4FbZSU3zD3WPFRhEbYlw5zkxwVbzl+85R9wa5csRIUHjIP/AcaWwcebPQvZX3fuK62tS0UjEa08/7bM81yuSVq5S3ikdXAADaYdacO6BNKN0PP/wgqtHxXEecI8SvK1euiO85H2jw4MEiBI69Slyg4YEHHhAGEVeqY7j0NxtB9957L23evJn+/fdfeuWVV8S22UNkdebvSnR2QJUro6rbDqtBtQaNug4vBcVXsknPgXalu937R/Jrzd6Zife0oAc7Vve5DV/lvXnQt1jBWJp4T0uX5Y0r+S+xLW/anKc7CcPIjHC1x75NyhsywN27UXnd92E3YBx5Icbt4b+rdXAx4l/c21K4T9+VhdjJ4Qf3j8c70r3tqola+He3cXWxFomPobtlbld5503ruQMAiHRgGtmXCRMmiAp1Xbp0ofLlyztfP//8s3OdDz/8kG644QbhOeLy3hwqN2PGDOf30dHRIiSP39louueee2jQoEE0evRosgt/bTkR8uCBMI78qKcdJ5IpKTVTVbW5YJ9LvXImudPNBsD/Ong3AOxK8yrF/VaQ69WoPMVo0D/p1SiBdr/RixYO7yI8Lf5C6twNtfzoIwke61qTJgxsEe5mWAqE1al4wNgt+0b/RjRtre/iCkqwa9mXe1kOT2jG+5q62rOSjxJaCB8rg6g6oBWlCuWnc5czRKgqsCdq4u7j4+Pps88+Ey9vVK1alf7++2+yK1wwgbksmxBWyUj5ZtlBKlEolm5u7pkbkuPgsDrfJk2f8UupSFyMCKHyx8UrmRQMVUoGNo+gv21JZcXLFYmneglFqUWVEvTN8oNkNkoUjBUlru/+crWm2510b0tqrzB5vLy/VEDjPFX2rFQvXUi81CBvCyIB8gbSezeG9ygQIrt3rdJz1LRyMcMMkbRMT4UkxyWszqC8KADsDpeJ/+mhtnRDEygQENlIRuR7/+72+E6ucrjy3LCfcyfuXLr3DN1ydSJZsQ2VoXCX0rNUeY4On/M915E3yhWNoyaVipEWyI9dOjYuWhMMnWTzDH77v2tIa9goYCPmn6c6abpdb5P5ys9N8YLhrXAqT2HgOScBCAZ4jnzExAaSvMZ5Q5uPJdEdrUIr0ZqW6Zac6qY35ArHqKIRANgdnjywXU1zJewCEA6UUoA4LygzJ4fe/2+Px3c8ZcW9X69x24aDluzxXoRBzmcL95NesJHwWJea9MgPGzTZlvPvEANw5SHxheNiLDP9hbcuBw8eP9ezLqVmZFGlEtp564KBc5W43DeXyNbz3FqZcsVgNPoDd44K1IyA/fxwOzp49jLVSyiiqeeI9ZS3gbVIdxmjPCUAAGjLX5tP0JPdarss+3f7KTp6IZVS0vMmY5Xo99lyj2Usmn/b4FppzGikcL3rGySI+QATihagD+d5GnfhoELxeF3zYqKCmMx+/1t9qOZLvsNFffU5hnatRWZBTW5SJPL3k53ockYWlS2Cyd39gbA6FUgCwZec4flg6pcvGrLBwiNuPtsiG7GKcNsIAACAD7Ycu0hv/b1T0ajxxl6FOYd4EtbvVh621MCV5MHgCIuxtzQJecJ091LlwfJyn/r0XI96zs/lZYaSVkhtDaSPwOfp1RusX44eeIfnlWpdzXwT4ZoRGEcBxLAaMdfCDU0qUOOK3mOk5U2AbQQAAMAbN326nCYtOUDvzdkVcjiVVKhBDSawjeietq6VX0MNQ/f36/vb+y8swdVoH+pcQ4R+zX6yI/36SDsqXTiOqpZSF4pWsXgBCgQerFXTLol721b1+t07tzYOaN8AWBkYRyqQEjqjDJoU9q8nOrqMwF1TXdnSj3TPkQn0LwAAmJ71Ry6E9PtAIyL8RUDoTff6ZT3mjwnZOJKdA6XDK13Ycz6dhhWKunyWh9A1rFCMWl0dxV/8XFdVbbi1RUW1raVgyB/jvUvYtZ7xk5UCEC6Qc+SDWU90pDOX0qlOuSJhM0ZKFs5PTSsXFwmGlUoUoIwsecGGyLaOzDA6CQAAZmfb8eSQfv/6n9sDWj/covmLe1sF1PFn2tcsRSv2nxPlxQe0qUL3tKlK+8+m0NqD5+nzRftp5I0N6Z6vV3sUbPJlQP74YBtqNnouaUWcyjLZPBGrViBPBUQiMI580MgtvO3bB66hh79fT2P6N9J93yxUP/hvt4iVlicYHruQV9I00j1HAAAAiJKuZNKnC/ZS/+YVhUdCiXZj59O4O5p5VGXkSnRaE07P0fSH2yl6ifzNvzP1obZi8FFuRFUpVZC61i1LT3evI5YP615H5BvJy0V7g9tQvGB+eqpbbfp4/l7SArnniSeh5dLaxy9coS7vL3IaMlyhTn4MgV4LDsObsuKQS54KAJEGwuoCoH2t0rT59R5CAelNh1qlacZjHaiuj+p3RuRAAQAAMDdjZu2gL5cepL7jl3ldh4sqDPxqlfh716lkemPWDrpwOYOajvov4Pn2/BIm24jzd7yHoXvqS/dKcd68S9Lyp7rXFoaS8vbdPl99H3a98vr++OzuFh7LCsfnjWf3alRelATnUHx5G9yPgT1i3lCak+i2lp6T+gIQacA4ChAld7qRuM61ENmEO3QDAADMwLbjSS6fs3MctP6wZ56R5CTq9dFS+mrZQWo+Zq6YiNWdR35YH1J7trq1xyjyR6vXinve6E1PXKdf+elABy/buBl1fRUmpGav0JDONeiVvvWdy+ReMqVd9myYQF8NakUrXrzOZUJcnoh2dL9GfiNmAIhEYBxZDLnsi3THUVnMfg0AAC6hU7dOWEEfzdsj3pVQ4xVatPtMSO0Z/O06Cgc8Gakaal8NPcvWM/wvQP38yd3N/a6Tle2gl/rUpwc71XAui5EZR2wUezQjKoq6NyhHFYoXoN8f6+BcXqWk9wp58bHoGoLIBjlHFibUWbqtypeDWtHvm46LEAcAAIh05H1i9hgpeY0kvpXlk9iNGJWeoytXDUQt063kRgoTqHYuUTCv2t3kB1p7fF+uaBw1r1LcY7ncc5Qjr9fkJfLl2/9dQzM2HKPne9ajxEtpyutF+sgriHhgHFkMl3mOIlR+Xd+gnHgBAAAILOl+7D+hzXlkJj4f2EJULR06dYP4XKN04YB+37pabqEjLSiQP4aG96hD7/+3R3y+vZVn7k4ZH9EOnD/0Qq96lJKeKYpAuLPshevEOu7E5MtbpsYTdm2dMuLF8HxLUx9sQ2WLxnvkOz0wZS2N6dfQ7/YAsCMwjixGpHqLAAAAKBOp0xr0aZybl1OmSDv6ftVhevWGvFwcJZ65vg59umAffXq12EGn2mVo8v2tRS5PqPDk7c0qF6dB7avRin1nqYvMwOHKcv/tOE2DO1b3uY1Hu9T0KMn9zPTN9MmA5oqGkbu3LNuf68hLoSmlOY04J8tf+XMA7AqMIwsTqZ4jAACIdLgIw0PfraPhPeqGfdJVo2DjYcKi/R7LuUKdtyp1cp7sVpseubamS6c/1MlNFw3vQkcvpArDiCkaHysqycnhz+7L1HBLi0p0Q5MKPo2UaFlHIDtw28grMIxAJGP43f/222+LBMGnn37a53offfQR1a1blwoUKECVK1emYcOGUVqacnxsxIbVwYsEAAARybCfN4ny3M/+sjkijKMeDcqJsLMaZQqJz08GWWlO605/tdKFhAdKL/y1N5+fggwAAJN7jtauXUtffPEFNWmSO7GpN6ZOnUovvvgiffPNN9S+fXvas2cP3X///cKoGjduHEUyqFYHAAAgQ+YmCCKaynJI4WO/PdKeVh88T9eF6PGxI5FgJANgK89RSkoKDRw4kL788ksqUcJ3EuSKFSuoQ4cOdPfdd1O1atWoR48eNGDAAFqzZo1RzbUEMI4AACAykYv/4xevkF14rmddeswt90YeKVGiUH7q1SgBYV8KwHMEgDYYJl2GDh1Kffv2pe7du/tdl71F69evdxpDBw4coL///pv69Onj9Tfp6emUnJzs8rIlCKsDAICIRz4huJ0Y2rUWPd+rXribYSl4AtnShfOryrsCAJgkrG7atGm0YcMGEVanBvYYnT17ljp27EgOh4OysrLokUceoZdeesnrb8aOHUujRo0iuyM3iGyqGwEAAPjBTuJ/yXNd6f3/dtPNLSo6lyUUjadTycgzVsO0IW0pK8fhtaIdACAwdH+Sjh49Sk899RT9+OOPFB/vWkvfG4sWLaK33nqLPv/8c2FUzZgxg2bPnk1jxozx+psRI0ZQUlKS88X7tTt2Uo4AAADUE67BsbG3NA76twPbVHH53L5mKfrxwTZUpVRBGj+gucv8Pj88eA3d0KS8mJOHJzp9GpN++/QiwjACwEKeIw6PS0xMpBYtcucVYLKzs2nJkiX06aefinC46Ohol9+8+uqrdO+999KDDz4oPjdu3JguX75MQ4YMoZdffpnyySY9k4iLixMvu4NJYAEAABgVVnd/+2pC13SvX45aVyspcn1GzNjqsV7PhuXo3+2nXZYtfb4rTV93lD5buI+e7VGXihWIddnuyJu8TzJaq2wR53xEGVk5yDECANjHOOrWrRtt3eoqSB944AGqV68evfDCCx6GEZOamuphAEnrcZhdJOOqDmEdAQBAJCKr4KwrSgbMzMfa0+Tlh+jPzSfE5xqlC1Gh/J7dicolCwqj6Inragvj5q+r6zPli6mLJGFgGAEAbGUcFSlShBo1auSyrFChQlSqVCnn8kGDBlHFihVF3hBz4403ipLdzZs3pzZt2tC+ffuEN4mXKxlTkYRdk3ABAACoJ5wFeZpXKSFeknHEakkqte3LuOnTuDw98dNG8XepwvaP9AAAWBND5znyxpEjR1w8Ra+88oowAvj9+PHjVKZMGWEYvfnmm2FtJwAAAGAGdp++5Hedp7rVpo/n7w1426/d0IBGz9pBsT4MHjmcE1SxeEGXZXe2qqy43kd3NqNVB85R/2YVAm4XAADY1jjiggu+PsfExNDrr78uXsAV+I0AAACooagsx8cXt7WsRN3qlaWaZQvTxdRMal2tBFUtVZDqly+q6vfVShWiIZ1r0OHzl+nvrSdFcYAXeyuX4+7fvKJ4AQCAWTGF5wioBwUZAAAAqKFyiQIey+YO60xnLqVTXGw0DZi0iob3rENDOntOutqtfjm/25/+cDv6cfVherlvfSqQP5rG3dGMPri9KcpKAwAsDYwjAAAAwIYUiY+lEb3r0YEzlyktK5sGXFOFapcrIl7M9tE9QzJieNJR94lHc8tKY+QOAGBdYBxZjHAm4QIAADA3d7WuTNPW5s7zx96ch6/19ApJwLsDAACeQDJaDXlYXTjbAQAAwFSULJSfnuiWN1lqfCxUPAAABAo8RwAAAICFOHo+1fk3T6w67o6m1KBCUSpdOI6yc/LmAoyLieypLwAAIBhgHFm6IAN8RwAAEGn0Gb/U+fendzenTrXLOD/H5HNQ00rFKCU9i6qUdC2vDQAAwD8wjiyG3ByCaQQAAJHHpbQs598da5V2+Y4HzWY+1oEcV+cVAgAAEBgwjgAAAACLohRBkA9GEQAABA2yNS0GQukAAAAAAADQBxhHVg6rg50EAAARRY6s4AIcRAAAoD0wjgAAAACL8Mv63DmMmJ8fbhfWtgAAgB2BcWQx4C0CAIDIZeqaPOOoZpnCYW0LAADYERhHFiNKFlgn/xsAAID9OXzusvPvIvGoqQQAAFoD4wgAAACwCBdTM51/x0ZDhQMAgNZAsloMhNUBAAAAAACgDzCOLIYjr1ARAACACCJbVqkOAACAPsA4sjDwIgEAQORwJTPb+XeN0oXC2hYAALArMI4AAAAAC5CanuX8u2Sh/GFtCwAA2BUYRxbDQQirAACASOTH1Uecf4+9pXFY2wIAAHYFxpHFyC+rTlS8YGxY2wIAAMA4ovPlxlK3rlaCapcrEu7mAACALcEkCRYjJjof/f1kJ8rKyaEi8TCOAAAgUuhWvyyVKpyfutYtG+6mAACAbYFxZEEaVCga7iYAAAAwmIYViokXAAAA/UBYHQAAAAAAAADAOAIAAAAAAACAXGAcAQAAAAAAAACMIwAAAAAAAADIBcYRAAAAAAAAAMA4AgAAAAAAAIBcYBwBAAAAAAAAAIwjAAAAAAAAAMgFxhEAAAAQAJ999hlVq1aN4uPjqU2bNrRmzZpwNwkAAIBGwDgCAAAAVPLzzz/TM888Q6+//jpt2LCBmjZtSj179qTExMRwNw0AAIAGwDgCAAAAVDJu3Dh66KGH6IEHHqAGDRrQxIkTqWDBgvTNN9+Eu2kAAAA0AMYRAAAAoIKMjAxav349de/e3bksX7584vPKlSsVf5Oenk7JyckuLwAAAOYlhmyKw+EQ71BEAABgLJLcleSwXTh79ixlZ2dTuXLlXJbz5127din+ZuzYsTRq1CiP5dBNAABgTt1kW+Po0qVL4r1y5crhbgoAAEQkLIeLFStGkcyIESNEjpLE8ePHRTgedBMAAJhTN9nWOKpQoQIdPXqUihQpQlFRUUFZl6y8eBtFixYls2O19lqxzVZrrxXbbLX2WrHNRrSXR+VY+bActhOlS5em6OhoOn36tMty/pyQkKD4m7i4OPGSKFy4MHSTybFam63WXiu22WrttWKbk02km2xrHHEceKVKlULeDl8gK9xUVm2vFdtstfZasc1Wa68V26x3e+3oMcqfPz+1bNmS5s+fT/379xfLcnJyxOfHH39c1Tagm6yD1dpstfZasc1Wa68V21zUBLrJtsYRAAAAoDUcInffffdRq1at6JprrqGPPvqILl++LKrXAQAAsD4wjgAAAACV3HnnnXTmzBl67bXX6NSpU9SsWTOaM2eOR5EGAAAA1gTGkRc4Rpwn+ZPHipsZq7XXim22Wnut2GartdeKbbZae80Ih9CpDaOL9OtntfZasc1Wa68V22y19lqxzXEmam+Uw261VgEAAAAAAAAgCDAJLAAAAAAAAADAOAIAAAAAAACAXGAcAQAAAAAAAACMIwAAAAAAAADIBcaRAp999hlVq1aN4uPjqU2bNrRmzZqwtGPs2LHUunVrMZN62bJlxaSDu3fvdlmnS5cuYpZ1+euRRx5xWefIkSPUt29fKliwoNjOc889R1lZWbq0eeTIkR7tqVevnvP7tLQ0Gjp0KJUqVUrMFH/rrbd6zDZvZHv5Oru3l1/cRrOc3yVLltCNN94oZnTm/f/+++8u33NNFS4rXL58eSpQoAB1796d9u7d67LO+fPnaeDAgWJiteLFi9PgwYMpJSXFZZ0tW7ZQp06dxH3Ps1S/++67mrc3MzOTXnjhBWrcuDEVKlRIrDNo0CA6ceKE3+vy9ttv69Jef21m7r//fo/29OrVy5TnmFG6p/n13nvvhe0cg9CBbgoe6CboJugm6CbVcLU6kMe0adMc+fPnd3zzzTeO7du3Ox566CFH8eLFHadPnza8LT179nRMnjzZsW3bNsemTZscffr0cVSpUsWRkpLiXOfaa68VbTx58qTzlZSU5Pw+KyvL0ahRI0f37t0dGzdudPz999+O0qVLO0aMGKFLm19//XVHw4YNXdpz5swZ5/ePPPKIo3Llyo758+c71q1b52jbtq2jffv2YWtvYmKiS1vnzp3L1RsdCxcuNM355W2+/PLLjhkzZoi2zZw50+X7t99+21GsWDHH77//7ti8ebPjpptuclSvXt1x5coV5zq9evVyNG3a1LFq1SrH0qVLHbVq1XIMGDDA+T0fU7ly5RwDBw4U99tPP/3kKFCggOOLL77QtL0XL14U5+rnn3927Nq1y7Fy5UrHNddc42jZsqXLNqpWreoYPXq0y3mX3/dattdfm5n77rtPnEN5e86fP++yjlnOMSNvJ79YnkVFRTn2798ftnMMQgO6KTSgm6CboJugm9QC48gNfhiGDh3q/Jydne2oUKGCY+zYsY5ww8KSb7bFixc7l7GAfOqpp3zeqPny5XOcOnXKuWzChAmOokWLOtLT03VRQPwQKsHCJzY21vHLL784l+3cuVMcEwuicLTXHT6XNWvWdOTk5Jjy/LoLG25nQkKC47333nM5z3FxcUJgMDt27BC/W7t2rXOdf/75Rwik48ePi8+ff/65o0SJEi5tfuGFFxx169bVtL1KrFmzRqx3+PBhF+H44Ycfev2NXu311mZWQP369fP6G7OfY277dddd57IsnOcYBA50U2hAN0E3+WqvEtBNdTVvr1V0E8LqZGRkZND69euF61ciX7584vPKlSsp3CQlJYn3kiVLuiz/8ccfqXTp0tSoUSMaMWIEpaamOr/jdrObWD57e8+ePSk5OZm2b9+uSzvZbc4u1Ro1aghXLrv2GT637LqWn18Oa6hSpYrz/IajvfLr/8MPP9D//vc/4cY16/mVc/DgQTp16pTLOS1WrJgIuZGfU3alt2rVyrkOr8/39urVq53rdO7cmfLnz+9yHBwqc+HCBd3vaz7f3EY57EbnEJfmzZsLl7s8HCQc7V20aJEITalbty49+uijdO7cOZf2mPUcc2jQ7NmzRSiFO2Y7x0AZ6CZtgG6CbgoE6KbdEaubYjTZik04e/YsZWdnuwgThj/v2rWLwklOTg49/fTT1KFDByEIJe6++26qWrWqEPgcg8kxs3yDzJgxQ3zPwknpeKTvtIYF35QpU8RDevLkSRo1apSIC922bZvYH9/M7oKG2yO1xej2yuHY2IsXL4oYXrOeX3ekfSi1QX5OWXDKiYmJER0Z+TrVq1f32Ib0XYkSJXRpP8f58zkdMGCAiIeWePLJJ6lFixaijStWrBCKn++ncePGhaW9HMN9yy23iH3u37+fXnrpJerdu7cQ0tHR0aY+x99++63IDeH2yzHbOQbegW4KHegm6KZAgG4qp1ubraCbYBxZBE7CZCG+bNkyl+VDhgxx/s2jRJz42K1bN/GQ1KxZ0/B28kMp0aRJE6GQWIBPnz5dJGSama+//lq0n5WNWc+vneCR2jvuuEMk7U6YMMHlu2eeecblPuKOy8MPPywSwePi4gxv61133eVyH3Cb+PrziB3fD2bmm2++EaPknLhq5nMMrAl0k/5ANxkLdJMxmFk3IaxOBrun2dJ2r1DDnxMSEsLWrscff5xmzZpFCxcupEqVKvlclwU+s2/fPvHO7VY6Huk7veGRuDp16oj28P44PIBHwNzbI7UlXO09fPgwzZs3jx588EFLnV9pH77uWX5PTEx0+Z5d1FzBJlznXVI+fN7nzp3rMjLn7bxzmw8dOhSW9rrDYTksL+T3gdnOMbN06VIxmuzvvjbjOQZ5QDdpD3STvkA3GdNed6CbEjRpH4wjGWydtmzZkubPn+8SMsCf27VrZ3h7eNSClc/MmTNpwYIFHm5EJTZt2iTeeRSJ4XZv3brV5eGQHvgGDRqQ3nC5SB7J4vbwuY2NjXU5v/xwcNy3dH7D1d7JkycL1zOXPbXS+eV7goWB/JxyTDnHEsvPKSt9jquX4PuJ721JofI6XIKTFYP8ODgERWuXuqR8OP6flT7HFfuDzzvHSEvhAUa2V4ljx46JuG75fWCmcywfcebnrmnTppY7xyAP6CbtgW7SF+gm6CZL6ybNSjvYqFwqV1OZMmWKqPIxZMgQUS5VXvHFKB599FFRBnPRokUuJQ1TU1PF9/v27RPlDrns6MGDBx1//PGHo0aNGo7OnTt7lPPs0aOHKLk6Z84cR5kyZXQrP/rss8+K9nJ7li9fLkpjcvlQrmYklUvlkq8LFiwQ7W7Xrp14hau9UtUnbhNXO5FjlvN76dIlUYqVX/zIjhs3TvwtVdDhcql8j3L7tmzZIqq/KJVLbd68uWP16tWOZcuWOWrXru1SypOrCHFpzHvvvVeUxuTnoGDBgkGVxvTV3oyMDFHOtVKlSuJ8ye9rqfLMihUrRKUa/p7Le/7www/inA4aNEiX9vprM383fPhwUbWK74N58+Y5WrRoIc5hWlqa6c6xvNwpb58rVLkTjnMMQgO6KTSgm6CboJugm9QC40iBTz75RAgknlOCy6dybfhwwDeW0ovnl2COHDkihGHJkiWF0uTa9c8995zLXAfMoUOHHL179xZ14FkZsJLIzMzUpc133nmno3z58uLcVaxYUXxmQS7BQvGxxx4TZRj5Zr755puF8AlXe5l///1XnNfdu3e7LDfL+eV5LZTuAy7hKZVMffXVV4Ww4HZ269bN41jOnTsnhGHhwoVFKdcHHnhACDE5PA9Fx44dxTb42rFi07q9LMC93dfS/B3r1693tGnTRnS+4uPjHfXr13e89dZbLsJey/b6azN3+LiDwQKay/1ymVGeX8S9U2qWcyzBioLvSVYk7oTjHIPQgW4KHugm6CboJugmtUTxf9r4oAAAAAAAAADAuiDnCAAAAAAAAABgHAEAAAAAAABALjCOAAAAAAAAAADGEQAAAAAAAADkAuMIAAAAAAAAAGAcAQAAAAAAAEAuMI4AAAAAAAAAAMYRAAAAAAAAAOQC4wgAAAAAAAAAYBwBAAAAAAAAQC4wjgAAAAAAAAAAxhEAAAAAAAAA5ALjCAAAAAAAAABgHAEAAAAAAABALjCOAAAAAAAAAADGEQAAAAAAAADkAuMIAAAAAAAAAGAcAQAAAAAAAEAuMI4AAAAAAAAAAMYRAAAAAAAAAOQC4wgAAAAAAAAAYBwBAAAAAAAAQC4wjgAAAAAAAAAAxhEAAAAAAAAA5ALjCAAAAAAAAABgHAEAAAAAAABALjCOALA4KSkpVLZsWfrxxx/JLLz44ovUpk2bcDcDAAAAcPLYY4/R9ddfT2Zhx44dFBMTQ9u2bQt3U4AMGEfANkyZMoWioqKcLxY4FStWpPvvv5+OHz8etOAaOXIkHTp0iMzKxx9/TEWKFKG77rrLuezvv/8W7daT1NRUsY9FixZ5fPf000/T5s2b6c8//9S1DQAA4EsXLFu2zON7h8NBlStXFt/fcMMNZDZ8yVYQvG4+ePAgffXVV/TSSy85l504cUJsZ9OmTaQnU6dOpY8++shjeYMGDahv37702muv6bp/EBgwjoDtGD16NH3//fc0ceJE6t27N/3www907bXXUlpaWlACeNSoUaY1jjIzM4Vx9OCDD1J0dLSLccTt1luB8z6UFHhCQgL169eP3n//fV3bAAAA3oiPjxedUncWL15Mx44do7i4ODIjvmQrCF43s66sXr06de3a1cU44u2EyzhiHnnkEZo5cybt379f1zYA9cA4AraDDaJ77rlHGAw8SjR8+HAhdMzkxbh8+bIm25k1axadOXOG7rjjDjIb3CYetT1w4EC4mwIAiED69OlDv/zyC2VlZXl0VFu2bCkGcUBkwAOJHHpuRl3ZvXt3KlGiBH377bfhbgq4CowjYHs6deok3t1HZXbt2kW33XYblSxZUowwtmrVysWA4tCM22+/XfzNI01SmIY0msd/K4WuVatWTYTyybfD6/JoJcc7c35QpUqVxHddunShRo0aiVEw3kfBggVFKOC7776r6th+//13sb+aNWs6l/G+P/vsM2cbpZdETk6OGMFq2LChOO5y5crRww8/TBcuXHDZ9rp166hnz55UunRpKlCggBhx+9///ie+49G6MmXKiL951E3ah/x8sMBn/vjjD1XHAgAAWjJgwAA6d+4czZ0717ksIyODfv31V7r77rsVf8Pe7vbt21OpUqWE3GMjiteXM3nyZCHvvvnmG5flb731lljOnntfhCpb/ekuud5ZsmSJkO98PEWLFqVBgwZ5yHpv8H7YmOD2cDvr1q1LL7/8sss6GzduFAOSvO3ChQtTt27daNWqVS7rcNvlOsi9jXLvD+szDnXkgbVrrrlGHF+NGjXou+++U62bleDtnT171qmXGF6/devW4u8HHnjAuR3evsTq1aupV69eVKxYMaGfOQpl+fLlLtu+dOmSCCXntrM3knU85zVt2LDBqednz55Nhw8fdu6D15WIjY0V60BXmoeYcDcAAL2RBC+PzEhs376dOnToIAwRLh5QqFAhmj59OvXv359+++03uvnmm6lz58705JNP0vjx40WMcv369cVvpfdAYcOIlQzHFss9R6yoWPjecsstQhGxIn7hhReocePGQun4YsWKFdSiRQuXZawIOVSAOwQcXugOf8/Cn5UBHx/HYX/66adCybHQZ0GdmJhIPXr0EO3l81O8eHFxHmfMmCG2wcsnTJhAjz76qDhX3HamSZMmzv2wMmGjjbc5bNiwoM4ZAAAEC3dA27VrRz/99JNTlv7zzz+UlJQkcjRZtiuFXt100000cOBAYUhNmzZNdMTZS8+5IQzLTpaFzzzzjOgEc/7S1q1bhTEzePBg4bHyRqiyVY3ukvP444+LfbCBsnv3brFt7qSzYaBksEhs2bJFDCyyPhgyZIg4lzzA+Ndff9Gbb77pbAuvw4bR888/L9b94osvREefBwODLcqzb98+YfzxubzvvvuEEcqDfmyo8qBeMLqZdSUfb/PmzZ3LeH0Ow2edzMcoDaSyccwsWLBA3De839dff53y5csnDOPrrruOli5dKow3KSyO9Tafa84hYoOcjbGdO3cK/cwGJd9zHMr54Ycfit+wISmH98HGUXJysjifIMw4ALAJkydPdvAtPW/ePMeZM2ccR48edfz666+OMmXKOOLi4sRniW7dujkaN27sSEtLcy7LyclxtG/f3lG7dm3nsl9++UVsc+HChR774+Wvv/66x/KqVas67rvvPo92dezY0ZGVleWy7rXXXiu+++6775zL0tPTHQkJCY5bb73V5/FmZmY6oqKiHM8++6zHd0OHDhXbdWfp0qVi+Y8//uiyfM6cOS7LZ86cKT6vXbvW6/75HHs7BxI9evRw1K9f3+dxAACAlkgyl+XXp59+6ihSpIgjNTVVfHf77bc7unbt6pTVffv2dfmttJ5ERkaGo1GjRo7rrrvOZfnJkycdJUuWdFx//fVCZjdv3txRpUoVR1JSks+2hSpb1eou6Ry0bNlSHIPEu+++K5b/8ccfPtvZuXNncd4OHz7sspz3JdG/f39H/vz5Hfv373cuO3HihPgd/16Cj0NJH0ltPHjwoHMZXxNetmTJEueyxMREocPlus6XblbinnvucZQqVcpjOV8H3g63xf04+Xz27NnT5Zj5/qhevbq47hLFihUTOtcXfJ/xsXlj6tSpoh2rV69WdTxAXxBWB2wHu8159I1H83j0iUfWOORACmU7f/68GBFiLw27w9nVzi8e7eFQh7179wZd3c4XDz30kEvRBAkeQeIcKYn8+fOLESl/uTp8HGyjyT1i/uD4e/bo8GindNz84lErbsfChQvFejzSyPBoKcdqBwu3jbcPAADhgOX8lStXhCxjec/v3kLqGA4fk3v1ecSfPQpSiJQE5ytx+DJ76Pl7TuhnD4e/Uf9QZGswuos9IuzRkWCPFFdy9RX6x3msHI7HoX5VqlRx+U7yNmVnZ9N///0nPFYc9iZRvnx5cX7Zc8JekGBg74vkxWFYn3NIXyj5q3yOAtGVfD35fPKx8G+lc81RHxw6yOeHQ9Sla8rhdxyxESxS26AvzQHC6oDtYIVVp04dodRYWbEQk1clYpc9GxWvvvqqeHkLfeCwBS3huHIl2GhzD29gQclhDWrIdWKpg4U9nxeOifZ23AzHVd96660iTITDADhMgpUgK4pAKjxx23yFbgAAgJ5wx5oHzLgIA1eB4049D5p5g42WN954Q3SO09PTncuV5BiH5nE1VM4nYSOEO83+CEW2BqO7ateu7fI9D4KxAeOryptkhHA+rC8Dis8nGy3ucLgaGw5Hjx4VYXCB4m6QSTpRba6UVrqS4bA+b7Au5XZxjjCvxwOyPNDIYZWc2yU3GtW2DfrSHMA4AraDvS6coMqw0unYsaNQPBxvzYpBGu3hKnY82qZErVq1gt4/K19/I5JylLxJagQ5J+OyIA1EYfCx+5owVkoE5u1yDDUn1nKM+b///itGET/44AOxzD1e2hvcNk46BgCAcMHynz33p06dEjkkkvfGHc4j4Xwjzmn5/PPPhRHBXhfOM1EqCc4eBS6uwHBRHZavnJfii1Bkq966Sy+8dfi96cpgdaIvuCBFoLqSee+996hZs2aK60jXij157OnictzsTePfvPPOOyKPzF/esITUNuhLcwDjCNgaFrJjx44VFW246AAnsEqjOaz05JVrlPA1isMjRhcvXnRZxgm8J0+eJCPg0AgueMAFFdS2m9efN2+eSOj1ZqzJadu2rXhxAi53DjhJmROUuUy6mhEublvTpk1VHhEAAGgPFyngQjRsfPz8889e1+OCBlwdjQ0WuReHjSMlhg4dKsLbWMeMGDFCVAHlIg1qCEa2BqK75B4Q+bw+KSkpQkf5Khoh7Wfbtm1e1+GBNK7exoOOSlXu2EhkT4o8ZIz1pdww5cIQwRKoh6VevXpiUJC9PRxa7m87UgVYDpNUc67ZkOaiS/xi7x0XYuBrKxlH/trLupLPGUe9gPCDnCNgezhsgb1JrLh4Ilj2nPAyrqqjZMhwuIAE5ysx7kaQJDw5ZE/OpEmTvI6G6QFXYpJGLuV4azePcHH7xowZ4/EbngtEWp9HsdxH6aTRMynUhBWj0j4kWAlxdSOp8g8AAIQDHuHnKm1cse3GG2/0OZjGnVi5DOfwM54ywR32/rCh9fbbb4tBNw6xe+WVV2jPnj0+2xKKbA1Ed8l1kjy3ic8Dy3pfHg02fNh7xmHpR44ccflOajufK666xxXW5CF6p0+fFsYeR2xI+VeSoSHXl5y7E8q8Pr50szddyW1fv369qu1weBy3m0u7s0Hp7VzzvcK6zv06VahQwSUsk/fjvp4cbheHIMoNNxA+4DkCEcFzzz0nyrFyCWsuu8l5SSy8uVw2h1vwSBkL9ZUrV4pym5s3b3YqLVYC7CJnwcajiVzGk4Ufj/Dxtjh+nAsc8G94xNFIt3i/fv1EuW5WyPIRJxbsDJc75fALPgZW3hzvziOoPNLJMfWs3HgUkkcXuVgDl7HleHxWWhxWwiOurCB4dPTLL78Uyk4acWTPEyfOcgeB981hfhyjLsWps4eKlRG3EQAAwomv3BEJLtU9btw4MbUCh+KxB4B1BYeqyXNAeTkXNmCPDJdvZjgygQvacMlpLkbgLbwuVNmqVnfJoxk4F4oHxtjLw/vm33P4oC+4TDavxx4QzqfinFk2gji/inUHw7lZXJCC12OPCUczsOHGRoF8rj7WM5xHxKW5WRezPmLDi40wd+NLLb50sxLcRg6tY73E60nwNWBv1sSJE6lIkSLCiOES5Hy8PIk8G5FstHD5ds7l4oIXfJ35enFYJF8/zhtmvclREmyI8z7Wrl0rQiXlOpmvJ3sWeW4lXk8y1Nl4leZBBCZB52p4AISlfKs72dnZjpo1a4qXVE6by48OGjRIlM2OjY11VKxY0XHDDTeI8t9yvvzyS0eNGjUc0dHRLqVDeZsvvPCCo3Tp0o6CBQuKkp/79u3zWspbqV1cyrthw4Yey/n3vsp+SnAJWd7/mDFjXJbzMT7xxBOijDmX+3Z/1CdNmiRKvBYoUECUXeXSsM8//7wow8ps2LDBMWDAAFGalkuoli1bVpybdevWuWxnxYoVYjtcztW99Oydd94pypcDAICR+JK5cpRKeX/99deihDPLvXr16oltuZeivuWWW4TcPHTokMtvuTw2r/fOO+943acWslWN7pLOweLFix1DhgxxlChRwlG4cGHHwIEDHefOnVNxFh2Obdu2OW6++WZH8eLFHfHx8Y66des6Xn31VY/jYd3H22Y9yGXSue3urF+/3tGmTRtxPHzs48aN81rK2/2aSLqSX2p0szeefPJJR61atTyW83Vr0KCBIyYmxqOs98aNG8X15jLgfL24fXfccYdj/vz5Th383HPPOZo2bSruiUKFCom/P//8c5d9pKSkOO6++25xLnkfcv3+zz//iGV79+712X5gHFH8X7gNNABA8HCIHMfEs/fHWyKr0XDiM4+8cQw9PEcAAGAs0kTf7MGQChRFOlyFj3OPeCJgNZUFjYILR3E4Jxd0AOYAOUcAWJxhw4aJmGg2RMwC53dx2AcMIwAAAGaAQxA5tI/zxMzCzp07Rfl4pTxgED7gOQIAAAAAsBHwHAEQPPAcAQAAAAAAAAA8RwAAAAAAAACQCzxHAAAAAAAAAADjCAAAAAAAAABsPglsTk4OnThxQkzqxSUSAQAAGANHa/PkiDxLvLfJMCMV6CYAADC3brKtccTKp3LlyuFuBgAARCxHjx4Vs8eDPKCbAADA3LrJtsYRj8pJJ6Bo0aLhbg4AAEQMycnJwgCQ5DDIA7oJAADMrZtsaxxJ4QqsfKCAAADAeBA25gl0EwAAmFs3IRgcAAAAAAAAAGAcAQAAAAAAAEAuMI4AAAAAAAAAIBjj6Pjx43TPPfdQqVKlqECBAtS4cWNat26dS5m81157jcqXLy++7969O+3du9dlG+fPn6eBAweKeOvixYvT4MGDKSUlxWWdLVu2UKdOnSg+Pl4kT7377ruhHCcAAAAAAAAAaGccXbhwgTp06ECxsbH0zz//0I4dO+iDDz6gEiVKONdhI2b8+PE0ceJEWr16NRUqVIh69uxJaWlpznXYMNq+fTvNnTuXZs2aRUuWLKEhQ4a4VJPo0aMHVa1aldavX0/vvfcejRw5kiZNmhRIcwEAAAAAAABANVEOdvWo5MUXX6Tly5fT0qVLFb/nTfHESs8++ywNHz5cLEtKSqJy5crRlClT6K677qKdO3dSgwYNaO3atdSqVSuxzpw5c6hPnz507Ngx8fsJEybQyy+/TKdOnaL8+fM79/3777/Trl27VLWVDaxixYqJ/f+fvfOAs6uq9v+alpn0ShJCCqEmgZBAaBFESqSICIIdARVBeaAC74Hyf4gCahQFFKX4AAEFpDyFJ0WKlCAktIRASCCUBJKQRnqdeuf/Wfuedc7a++x9ym1z79z19TOfmbn33HPOneBed+31W78ljkCCIAilQ9ZfN/K3EQRBKO/1N1Xl6B//+IdKaL74xS/C0KFDYd9994Wbb77Zf37x4sUqoUEpHYE3cdBBB8GsWbPU7/gdpXSUGCF4PE6qxUoTHXPYYYf5iRGC1aeFCxeq6pUgCIIgCIIgCEKhSZUcLVq0SFV1dt99d3j88cfhnHPOge9///twxx13qOcxMUKwUsTB3+k5/I6JFae+vh4GDRqkHWM7B7+GSUtLi8oI+ZcgCIIgCIIgCEJRkqNMJgP77bcf/OIXv1BVI+wTOuuss1R/UVczffp0VaWiLzRxEARBELo/2Ld6wgknKFk2DvdDCTZHjIIEQRCEoiRHGFiwX4gzfvx4WLJkifp5+PDh6vuqVau0Y/B3eg6/r169Wnu+vb1dBSZ+jO0c/Boml1xyidIQ0tfSpUvTvDVBEAShQtm6dStMmjQJrr/+euvzYhQkCIIgFCU5Qqc67PvhvPPOOypYIGPHjlXJy1NPPaUFFAxGU6dOVb/j9w0bNqjgQjz99NOqKoW9SXQMBqa2tjb/GAxYe+65p+aMx2lsbFQ7fvxLEARB6P4cd9xx8LOf/Qw+//nPh57DqtFvf/tbuPTSS+HEE0+EffbZB/785z/D8uXL/QoTGgWhMdAtt9yi4tChhx4Kv//97+Gee+5RxyF33XUXtLa2wp/+9CfYa6+9lMEQysqvueaakr9fQRAEoUySowsuuABefPFFJat777334O6771a7Zueee656HuUM559/vgpSaN4wb948OP3005XU4aSTTvIrTccee6yS47388svK/e68885TgQaPQ772ta8pMwaUNeBO3r333gu/+93v4MILLyzG30AQBEHopohRkCAIgpCG+jQHH3DAAfDAAw8oCdsVV1yhKkW4I4dyBOLiiy9WEgeUI2CFCHfgcEcONdoE7sBhQnTUUUep4HPKKacoyQMPXE888YRKuqZMmQJDhgxRenEucRAEQRByI5PphIv+9w1obKiFK0/cG+pqa6C7UkijIIx55jnoOZeqAc2C8IsQsyBBqHya2zrgO3+ZDUeOGwpnfGLnRK95dN4K+MusD+G3X5kMw/oFn4ltTP/nW/D4m3YDMs4huw2Bn39+ov/702+vgj/OWAS/+eIkGDWoF6Rl9ofr4VePvQ2XfXYC7L1Tf5j+6Fvw+PzgPhrqauFHx42Do8YPg7/M+gD+9dZquOnrU6BnjzrnObF6/5/3vQ5zloQ3kXbo2wg3nDoFBvXuAefdPQfeWhGsj32a6uGqUybBhBH94OePLIAnF2Tba/Bvd+93smq0skiOkM9+9rPqywVWjzBxwi8XGHCw6hQFSh9c85QEQRCE3Hnjo43wtznL1M8DezXARceM6+pb6ragWdDll1/e1bchCEIBeWPZRpjxzsewZN22xMnRva8shVmL1sIL762Bk/cbGXnsLf9eDB2Z+DGkH6xdAv/vM+Ohd2P24/z9ry6Dlxavg2cXrobTpia7L85Dry+HlxevUwkRJkc3/3sRmLfxv7OXqeTojlkfwnurt8DryzbAwbsMdp7z480t8PfXPnLc/zaY+f4ada1/WpLBx+avhPE79oVbnl8MNJW1rSPxeNbSJUeCIAhCZYPBmbj+mfdh31EDYdoEvbLSXeBGQWgqRODvkydPLqpREIJKCy4Jx8qRuKkKQmVDicv21o7Er2nPZLTXRlX26Zg/fWN/6NfUYDlXJ3zlf17M/syShbaOTF4JBF23w/tOt3rrGfvDKx+sh5tmvM+ukez9tHnPN9TVwF/POth//GePvAVzl25Q90/voV9TPfzpGwfAn15YDI/OWwkdmYy6B0qMbvvGATC4TyBtLhaSHAmCIFRpcjRyYE9Ytn473PL8IpUcvfnRRrW72auxDgb37qF2N4f0aYRKhhsFUTJERkE4q880CkIpt8so6L//+7+VUVBDQ0MioyAyC8IvQRC6D53gJUdtyZMjSiLog77zOHbAlDGDoH/PBmsCZTuekqJM3EVirt3pyeGIyaMGwLqtrX5ipr4nvBbda31tLey/8yD/cVQtqGtmOv3EsbGhTh2DiVH23Pr59xs9EPp7rysbQwZBEAShtGCAWrxmqxao8gF3Ol/9IKv9/oYnB6Hdz9/+6134y4sfKs36Lx59GzZsCxxDyxmcRzR37lz1RSYM+DOOmRCjIEEQCg0tx9h7lBTv87+fWLnglZh6Rz9obW0N0FOUWPDXUgKTFkpkMp2dmpyutqYG6utqIqtLce/H7G2tq631EzJ6C/R+6dDsfQQXqClR1iKVI0EQhDLmjpkfwE8fWgC/PHkifOXA0Xmf79UP10FrRwZ27N8Eu+7QRwtu29va1fdP7j5EVYywWbYSePXVV+GII47wf6eE5YwzzoDbb79djIIEQSgo9IG9pT2jNq5wEybpa+KSCZ7YRJnl4HOZjkCCl0bqlqS61cmTkpps5Ydfg5IyXsWKet/mW6mrDa5JFStMwui9BffBXpPg71wIJDkSBEEoY7BhFflwXfZ7vrzw3lrf5Qh3H7UdQG/37kv7j4ITJmUrJpXA4YcfHllZE6MgQRAKCV9uMEFqanC7tRGUAMTJ0Do64itHlECgjI4nQpRY5Zoc0cs6jcoRrqF0L2Z1KlZWR4mP8V4o2VLJkRd8qDpFyWb2ueD8lDwVG5HVCYIglDG0Sxe3O5cUdAZCDtltsL8LR8HL3L0TBEEQwvCEIKm0jtbwOIU0l8lFVY54chG8Nk9ZHatuZdiN4m3QvVBfEyVx8bI6770YcYVvzpnHOGV1JQpNkhwJgiCUMYGuuzDJ0epN2Zk7u+3Q1w9AdGqqvnTjsUeCIAh5w1fjpKYMvtlBzFpOiQ0mI1FyvaDniCVHvqwuSLDS4DKNqKmpUTOO+DFtCd336HmzcuQVibTqEB1DG3R4H2bvUymQ5EgQBKELqkG/f+pd61A8k0AmUZhrU4DmgdfUwifRzwuCIFQrPMFpbku2ONManrTnKG44d72XrHBVATnI5RovuPQv46gcmdK9uGSPzmNWjrghA53LN2TwvuNr+flLNbBckiNBEIQSg0P2rn7yHfjlP98ueeXID0J1gdsRBUSXq5AgCIIQwAsz6WV1yXqOovqNEDNZyf6cX+WI31sn7zmCwK2OqlNBz1GubnXB86ak249NoZ4jKAmSHAmCIJSYrS3tiYNq0qbXKHCKeWu7LoHAIMQdgbLfRVYnCIIQB1+NkyZHQVUm+jhKcGIrR4ZBQiF6jvhmXMbhVkcJCz3N5yxZz+kbMuiP0/vDc1HiSI9RkpTtfQpeUypVgyRHgiAIJSaQscUHMNoBTJocYZD53l9fg3PvnqOCzh+efhemXTMD/jjjfe98wa6kS1YnhgyCIAhu+HqctOeIzxCKwpSYuaB1WkuOyCQh5+TIu1eUs7HH8VK8UsVNI2JldRmXrC64f1NKGPTDdnbJpp0kR4IgCCWG4lYS5UMwhTzZuR+fvxIeen05PPLGCnjgtY/gN0+8ox7/43OLQhIH7gjEv5uNs4IgCILDyjtpz1HCDS5KFKinyIUvc7PI6vJ1q+vE+UIZPRFrYLI6ikv8NekNGYLNOVN6x3uO6K2UUu4tyZEgCFULyiHeWLYhduer0PiNrCmOTbITiO/jD8+85/9+6YPz/J/RupufD4MPBRtK0gLJXfL3IgiCUN2GDAkrR52FrRzxykvYkKHQVt41RuUoeC7O/ME3AXJYeeO5TNOGoCoW3EcpjYIkORIEoWr5zl9mw+f+8IKqsJSSYHcuHMAw0H7ztpfhF4++lbrnaMY7H8P85ZugZ0Md9O/ZoLko+XrxziDwBrpu3b5VZHWCIAhueO7R3J5UVhd+bT5udZRIFHIIbPC6Tl1Wx2IIXoOfPy42ueIKJX+ZGFldV2zaSXIkCELVgskEcpPXj1MqXLMkkL/M+hCeWfgx/I8hg0tizfqnFz5Q3089aDScfdguoWvqgQZ7juw7mpIbCYIguOGpQ3Irb/e6rx+XyaNylGz2kAs/FmQgbMigyeqS9xy5ZHW1iQwZOrtk066+ZFcSBEEoU1Z5g1FL3nNkCSoPvbFc+5005Emkf8s3bFffjxw/FCaPGgDL1m+HRR9vgZcWr/OkC8GxvHJEcc4lfxAEQRAC+Fq6vTWtW130Wk7SuPg5RyRLCxKVNtpMy1EqTqfqxP8ZLnHcHS8nWZ3pVlcTlumZQ2C5vK+UcUkqR4IgVD0bt7dFPp+r80/c+bi8Du29Nze3wRvLNmrHdqQIdnRenGTeq0c9TD95IpwyZaR/LW1eBOs5osTL36GTpiNBEIRkPUeJZXVuObXVkMH0vk4gq+vI18qb9Rx1Gi5xZBDRllJW53Krq+emC+YQWDaDrysUDVI5EgRBsICB4ZmFq+F3T72nqi8PnXco7Dykd0HOTQGIQsqvH1+o3OQO3mWQdhwGjLYUbnXmID0ebEydeLZy5HCrk9xIEATBCc8HEsvqjE2ovHuODFkdl03TINl8Nu46vcfICIFXjtoKKKtrtw2BZRt3XeGiKpUjQRC6FTjw9PM3vADPvL069lg0LnBx36tL4Vu3vwqvL90Am5vbYcGKTQW7R1N7/sJ7a9RjL7y3VjuOJzRJqlc2OUYQQDNa9alOm3MERnIk2ZEgCIILXi1pSToE1k88EvYcebI5F3woK0IbafnI6vzXdYY3y2xzifj1XbhkcTZDBnrMj02q9wlKHpckORIEoVvx7MLV8NqSDfB/c+Md6Ib2a/R/Rkkb5+9z9NfnKlNI4lbXr2eD9TgehJK41dmCEA9ofDcxO+coCE7Z79nnJDkSBEFww5fjQg+BTdpzRKo7m0Nd7oYM9D3oOaJEpYHJ/Lh9eXyyB6kNGfgMpK7YtJPkSBCEbkWQTMQf21QfVI5WbGzWGmwxwUJGDuyp7eYVgiBIer97i//503aHu886yD+uDas93nWTJEfmID1Tl65VjnBuhWHlLZUjQRCEeDI5zDky5dT5zjmiyhHdC8YLIuchsGwGX4Z6fbzn6lglq6U9uFbs3CZH5UiLTSFDhuDcwaYdlAxJjgRB6FYE0oX44MCDCTm9Ia9+uA5aOzKwY/8m2HWHPuoxbSJ4phNeWrQWtrS053aPRlJEt7HLDn3goLGDg+M6gspREitvv3JkkdVlHYGyJ8GYhEEosPLWXy+5kSAIghseXZL2HNE6WzBDBlrbvYBixqhc4NK/TkPOxpM1vXKU0JDByG58VQPrlaqPcKuTypEgCEK+/TwpjkWWbwgqRzPfz/b+fGLXIdDg7ZbxY59+ezV8+X9ehOneoNa0BK5F2d+p9RXjQrYXiFeOkjkc6Y28wWOkW8drUhLmTyFnbkHZ9+g9L44MgiAIydzqCiyr8xOFunSGDNzSm/+cq+S705fVgSU54pWjZOc0cxtN8m0kQHwGX1cYBUlyJAhCtyJVMsF22njlKEiOBmuVF2LFxuyxK5kUL9U9Gj1HZsOpNk/Cu8ckDbZ8wCtBP/PKkU3Xze9HZHWCIAhueELQzCRmXeJW552Qx7N8h8B2Wio2dTlWjmxyb+3+mayONvbouWzlKPuYuNUJgiDkiClVi4LvrlFytKm5DeYty/YbfWK3wSFHIKTVC0I0cC/Xe6RXU1JCSz9dE4NdUocjdYxFjsHv368chXTd+n1J4UgQBCGhlXeCIbC8EpPYrS6256im4IYMXJbe6T1WYxkEq/Uc5ehWZ0+OsvGKmwWJrE4QBKGEPUc8gHzkJUcvvr9WBa9dhvSGHfv3tFaO2j39Wa4mDeEhsPZ5EnxyeBINuS9NYCs7/dxhqRwFVt56AkaPC4IgCDGGDAmGwPJYk7TnKHHlyItHfPZQvm51naxyxMMBXbMQbnU2QwaqHGmyOl8RASVDkiNBELoVSR2BwlK5rETuX2+tUt8P22MHQ+IWBB4KQnyuRKp79E4V7CTqQYi05piE5etWp1WODMMGOgwfVsP2EgZlQRCEakY3ZEiQHLH1O24l70hpyEBhSNvAy1PVkLFYeWfvqSa9rM5ROfKtvFlfkd8Pq1l5e8dL5UgQBCE3aJZP2p4j7CPCZOSpt7LDYz89YZj6bqscUVKUs3TBqNTQWQJttyerSznnyE+ObHOOlCOQHuB4EqS7AuX0tgRBEKrQkCFeQcBFBnEqAIoviStH3skL0XPEDY06LfGg3ivtpJLVOTbdtN5aQ1an9xyRIkKSI0EQhIIkHkl7jjAgPTJvBazd2gr9murhwLGDtCoOH6BKlaNcd+c6nYYM2e/kkKf1HMXEX1X58c5jtfJWtuAZwxGIJ0dds0MnCIJQafCEIG3lqFg9Rzye5SyrY4ZGGUs88HuOUsnq7MkN7zkKEii6ZnA/4lYnCIKQJ0ntUvmiPbRvo/r+w7+9ob4fMW4oNHirtLXniIJRkuFDEdcNGTJ4i39wzYy/Gxg7S4I9rcvqmDzBqBzxYIPPBz1LkhwJgiC44Kvx9raUPUdQ6J6jzpDMO19VQ2dncJ98r4w2C7lDX3xsIkUDJDZk4P2wwRBYqRwJgiDkRFK7VExIKJj8+ouToEddrS+PIEkdYnOro8pR/rI6uyEDJWbcfjvOypvvGvLkxmblHUwhZ5WjjF1GIQiCIOjwpb8lgayOy/DiYhMlO4nnHPlz6lhylGBz0AZ3Ls1kbD1HtaFqWdy1nJUjlgCZM/psQ2BLaRQkyZEgCGXN9H++BefePSdRD1Eatzoe3CaN7A8/Om6c+hmTpE95ZgzunqOwO1A+Q2Bd8yTa2jMsWMWdM/iZ9xz5skCLIYPecySyOkEQhCTweNSqjHOSJQhJYlPSypG5cceVDLz/KDflBQSVI4h2q4sLzb7c22HIgO/XNGSgJCkr79MTp1JQX7pLCYIgpOePMxap7986ZCxMGTMwxRDY6ON4YoML/jcP2Vn9PGJAT+jb1OA/Z3Or8wez5mmXGrLQNq6ZpumV797Zeo74QNnAypvfUxCEJDcSBEFwY8aXlvYO6NWjPplbXWdh3Oq4KsCcu5e3rA6C+6y1bLblMufI3HTzJd8WQwaqEuH92O6j2EhyJAhCRbC5uS3RcZTzJJ3aTUEIF+NvHTo2dJytcoQ7heZjaTATuEDOVmMEoPRTyPk9h2ZJOOxSA1md/hpBEAQhjLkeb2+NTo40t7qElaNYQwYvTlBywjfwcpXVBbGpk8m92TUtlaNcZXWalbdLVpcJXi+yOkEQBIMkjkC2Ph4XPLGJ0nZzu1H/tV4FJmfpguFWF+yMmbpu3vQKyZMji5U39huZc5B4ctTGe5YkORIEQXBiLsfcoKBQbnV1CXuO/MpRAQwZgg07sFZ86iyxKWklzJTFUZzirqxBP2xY0SBudYIgCAbbWjsK2nPE9dlRlRI+c6hQVt7BPYJ+r35yZKkcpdC08x06f14E24Ezh8CGXi/JkSAIghMzvsRt3unrd2EqR1wVoF7HkqN8nVQzDpl1Qw6qBrOfyOakGkgJa7Rjs0ma/n5LgSRHgiBURNNr2uQo6W4WrsVR1tX2OUdeMIobPhRXOfKCJJ3ZlNXplaNkAcgMqPWWyhE9hjIFije8BytG6i4IglDVmMtxXHKkGTLEhA3T1toF7yc141GO+3aGlXcWnpMEhgzJZyrFyeowGfTHSBgz+LI9R/aepWIiIVAQhIoIQElldYkrR5QoxFjgRLnV8YQpDRTDzMqRnxx5QZHvzuVsl8omjdN7sFl9S+VIEAQhGaZ7Kk8W4mV10Ws5bb6lHgLLK0e5btyx+NlpSUoaLFbesTJBR+UoUDXwOUdhWR29vpRhSZIjQRDKFh5EsOE1rdtOFO0pA5DmVpfJU1bn6Dmixd9WOUqs63YEIKTV08Xz90zHc726JEeCIAhuzKU/jawuLmr4PUcxsck3NKBZeAVwq+M9u5262lu7J+5WFzdmIzBbsMcmjIemqoHeG5fVSeVIEATBCEBJppCr1ySuHCULQObuHNLWnqeszulWp19TqxwllC64AhBPjniQoR/5+SU3EgRBKJysji/fBXOr85OjsKlOLslRdqaQ9zPY594FG3dpYhNEDoHtsBoyBP1IFB/jYnUhkeRIEITKqBwlldUZs4Ocx3kHNMTJ6rzneQBoK1DlyJxzRHt0dre6mADUmSA58qIUd+ejIGTOfRIEQRCSGjLEyOp45SipCiDOkMGoHHFZHZ4izsQnOoGDoCJksfLW5hzFXMZlyMArR2bPLL11PrxcZHWCIAhGEEksq2NzGqIgGVkulSMKQniJXHbogt05+l2vHJGFa5op5EkqR5QA8Z1Aepq/P5HVCYIguDGX4/jKEU+OCls58nuOjFiUdtaReY8ZS+UosPLmsSmZWZD5doLkjvXDGjP4lKyOKk8iqxMEQQjc3FJVjlK61cXapVrmHPEqSy7SOi6r48P2aPFvyMcRKGSXWhvZc2Tq1rPnSP2WBEEQqgYzIdiexq0uLjbRxl1CsyBKPkz77rQbd+Y9dnrxt9Zi5V2IIbC88uWawccNGWTOkSAIghFECj7nyEsGogbAqucj3OrU4zk41pkSCwq0lNfQ7lyaWRKuQXs8oJAUgleTKAjR+8BfSzmJXBAEobvPOUrjVkexhjbJYmfwdTgqR6lldbppRKevqquxup8Gr8tTVsekc35y5MUx6TkSBEGIWKyTWnmH+3jipAtJZ0kECRF3dsul76jDDEJgVI7ymnOkvx9MdEyHIT050t+HSOoEQRCiMZdj3oNTKre6wJCBKkf6mdPGJn3TrtPa62NTWiTduHMaMmQ6/Xs3K0e4D0m3VcpNu1TJ0U9/+lNvaGDwNW7cOP/55uZmOPfcc2Hw4MHQp08fOOWUU2DVqlXaOZYsWQLHH3889OrVC4YOHQoXXXQRtLe3a8c8++yzsN9++0FjYyPstttucPvtt+f7PgVBqEA6M8XrOUpu5a3vzmV/zt8ViLBNIg+SmeSzJIIZRuHnKAi1RlSOgn6k1G9HEAShqkhr5W0mHslm8CWz8g56jvQELT9Dhk42YoK71YUDTNx1KFxGWXmb1aWg5yh4rqxldXvttResWLHC/3r++ef95y644AJ46KGH4P7774cZM2bA8uXL4eSTT/af7+joUIlRa2srzJw5E+644w6V+Fx22WX+MYsXL1bHHHHEETB37lw4//zz4dvf/jY8/vjjhXi/giB0d7e6hD1HSa28bT1HrY5EKVdZXcaQL5CDXkuKniN/loRld43eQ5Ac1Vp6jihBk+xIEAQh3RDYFLK6mJARSKSjP6LTxh7FSa5oyKVylAnFpU71c22elaM4WR3+PaKGwGa6QNVQn/oF9fUwfPjw0OMbN26EW2+9Fe6++2448sgj1WO33XYbjB8/Hl588UU4+OCD4YknnoAFCxbAv/71Lxg2bBhMnjwZrrzySvjhD3+oqlI9evSAm266CcaOHQtXX321Oge+HhOwa6+9Fo455phCvGdBEKpgCGziWRIJe47auFudNhA2F1mdfYeOYiEFiOYceo5M6QJ/D60d2fPxt0yH++59khwJgiBEYq7GcZt3fPnmRkP5uNVRnCBVA5d+Z39PKavTFA3g3yUPCbbNxKRjM1yGDBhPQ8mR1o8EzthWNpWjd999F0aMGAG77LILnHrqqUomh8yePRva2tpg2rRp/rEouRs9ejTMmjVL/Y7fJ06cqBIjAhOeTZs2wfz58/1j+DnoGDqHIAjVA19zkxsyJEwmfFld3JwjS89Re36GDOYOXTAE1ptz5F2TV45i3feMORGc2qjKEdN9Z39P/XYEQRCqClNKlmbOUaxEuiM3VYNZOUpt5W1I/zqNuOSaCxgrq/MrR/rjgSNdcIw5BFavYJVp5eiggw5SMrg999xTSeouv/xy+OQnPwlvvvkmrFy5UlV+BgwYoL0GEyF8DsHvPDGi5+m5qGMwgdq+fTv07NnTem8tLS3qi8DjBUGobHiCs621PdlrUsrqEs+SYIHHVUXKzRWI9RwZ1+SVo1ytvPn5guQIwm513vsQQwZBEIRoaDXuUVerhmvHyas1E56EKoDEYybIytusHKXcuOMhplNt2kFIam2vHCWUfBuv5e+vrV1/z5qsjipHJQxNqZKj4447zv95n332UcnSmDFj4L777nMmLaVi+vTpKlkTBKH7wNdcrBxhUInriaFAERcWSLqQS89RW56GDOF5ElnovVE1i1eOklt5R1SOOmw9R6Alf6WULgiCIFQimvV0RwI7a0MtUIjYZI6ZMGNR2o073UW1k/XCsmtaZOhJrbzN2MJ/92OTYciA5+6KnqO8rLyxSrTHHnvAe++9p/qQ0Ghhw4YN2jHoVkc9SvjddK+j3+OO6devX2QCdskll6i+J/paunRpPm9NEIQygCcEGADi7FLTzDmi42wyAQ4lKnQ8fuenNqUMOU0iNyRttspR4qbXiJ4jSraiK0ep344gCEJVQcsxJQtJB6GmiU1xkm9zgLcZi+KuE5XAZQpoyEB7iWZyw2MVqRp8WZ3Fya5ikqMtW7bA+++/DzvuuCNMmTIFGhoa4KmnnvKfX7hwoepJmjp1qvodv8+bNw9Wr17tH/Pkk0+qxGfChAn+MfwcdAydwwXafuN5+JcgCJWNuSOVpO8oaXLkGxAkbXr1dd35Nb1aK0eGfIHsUvXKUdw59fu1vQdzd0638i59ABIEQahESBpHyUKcVI7Ho6RjGZLPOQJH5SitrE5P4DqtsrragrnV8USLNj5NWV3WyhvK28r7v/7rv5RF9wcffKCsuD//+c9DXV0dfPWrX4X+/fvDmWeeCRdeeCE888wzyqDhm9/8pkpq0KkOOfroo1USdNppp8Hrr7+u7LkvvfRSNRsJkxvku9/9LixatAguvvhiePvtt+GGG25Qsj20CRcEobowGz23trQnT45i7VLT9RwFTa/6idty6DnSNviYrC6qchTfcxROfIjwEFhuyKCfX6y8BUEQoqHlmNbS+PU5+DkuZQlUDUkl31Q50mNRWrMg7T10cqOg4OEGW+UooTV5SFbHYo0/Z88wZMhUgiHDsmXLVCK0du1a2GGHHeDQQw9VNt34M4J227W1tWr4K5ojoMscJjcEJlIPP/wwnHPOOSpp6t27N5xxxhlwxRVX+MegjfcjjzyikqHf/e53MHLkSLjlllvExlsQhESVo6RSgqRW3txuVH03HYEKOQTWU3fTPZlvJarnypcuRFWOIgwZKDjFqAwFQRCqHrLjNqs3hTBkSDyDz5dEe4YM+crqzMoRgBaX1DUt8bIjseRbf5xvTFJsosdqbHOOShibUiVH99xzT+TzTU1NcP3116svF2jg8Oijj0ae5/DDD4fXXnstza0JgtANMRf3rQkc65LK6iiQxOm6fU25o3KUi5W3qT/3kyOjcmR7nSuZC+xSLclRTRorb6kcCYIgJKscJZTVpek5Shmb6NztecrqzOpWxohLSIPlnpK675mxxWbIQMdQzOrkNt+V0nMkCIJQ0p6jlsL1HOXqCMRtvLOP5yCr485FrEJEwYJ6jkyiYh0FSFvyFOo5YqeneEPvT5IjQRCEaCghIOlb0upJ9rWFclKt1StHeQ6BdfUc1cZaeUPOTqqmG6w/BJZdsys27iQ5EgShe1WOvNfEL9iZhLK6Wm03jw+AzWV3LrLx1b+m/Z6iEr6o5Ibeo61yZE5ZL6V0QRAEoRKhpZjWz6QJQiq3urp0/bBpJd/PvL0a7nzxQ+vxnazXh4cU2z3FXcdlyBA1+4jHsSC2QXnK6gRBEEqJWa5PMgiWFuq43TlyZ0s8BNaxO5dEVof3xINAJmTIoCc2rkbcqKDqGrRnldVZ3OpkCKwgCEIyaC0m6ZtpHuQ6PvtzYSpHpiQ6beXowvvmwvptbTB118Gw6w59nNWtWhYT6vOR1UXEJv9a1HPELkMDdktpFiR7hIIglC3mmrslgayOglTiKeQxDgRm2b/Vm+QdnCdaVnfLvxfBnpf+E179YF3oHtXPaocu+zPFDptdKh3rfD8RumxTVsd3/+iaIqsTBEHIrXKUxq0uzq6OkoHYjTujH9bcqItSNeBGIyZGyLurtmjncfXCuuccQSR0W0kqR3QMPzbp2I1CIsmRIAgV1HMUXzlqT9lzlLxylLFXjmIiw9Nvr1bH/P21j/zHuD6dByHS1dnsUtXrIq4VDA6Md6vjCRDtxgW7c5FvRxAEoeqhpdg3RYjbjDPW/ML0HEX3w0ZVsz7e3OL/vHjNVu++QJfVZWxzjtLL6nxLcEvGEUqOInuOoGRIciQIQgX1HCW38o6VLvjmBMkCkKrwZDpDU8jjZHUrNjar7y8tWhtvyEC7Zo57iqqGJWl6Ne1S+XP+7lw3zI46Ojrgxz/+sRoV0bNnT9h1113hyiuv1P6e+PNll12mhprjMdOmTYN3331XO8+6devg1FNPVUPGBwwYoGb74TB0QRCqC1o7gvgQI6vLpecopgGU1mo6viPFxh1PjhZ9vCXGyju65yjp+4lSNZi/80O7QtUgyZEgCGWLuegmqRwFPUfJFuyGGFkdD1C4+xey8uZBLxPMZKB7WLFxu/r5/Y+3wpot2YDEb40fH/Qc1eZcObLpuuk9+Hap7BhzCGx3lNX96le/ghtvvBH+8Ic/wFtvvaV+v+qqq+D3v/+9fwz+ft1118FNN90EL730kprDh/P1mpuzyS2CidH8+fPhySefVDP7nnvuOTj77LO76F0JgtBVdBrW1mkMGaIOxZiRtnLkNmTIrvcYd46+doaSeEdVjsx7zFiGwNp7jiJvM3Ljzow3tsqR9BwJgiBELLpxlSMMLLS+JzVkiA1AbKcMF/mQrttbuPHaJ984E074w/N+wrNhWxs0twXJ1MuL14WCEP853q0uiSNQ+DkzYeKVI19W5528G+ZGMHPmTDjxxBPh+OOPh5133hm+8IUvwNFHHw0vv/yy/2/329/+Fi699FJ13D777AN//vOfYfny5fDggw+qYzCpeuyxx9RQ8oMOOkgNQcfkCuf/4XGCIFQPwWDTZD1HSQ0Z+HNpe47MjTv6dc6H6+GdVVvgoTdW+M997G3UIYtIVmds7IGhaODXzGkIrM1J1VE54jEwSBahZEhyJAhC5VSOYtzqeGCJL/UnbHo1FmlX5ailPQNzl26A+cs3wRbvPpd7VSOCpHU8mPCfKQi5LFyTyerCy7r5Hnmy5E9ZTygzrEQ+8YlPwFNPPQXvvPOO+v3111+H559/Ho477jj1++LFi2HlypVKSkf0799fJUGzZs1Sv+N3lNLtv//+/jF4fG1trao0uWhpaYFNmzZpX4IgVDadaXuOzMTDAe9pjR0zYTiN0jUa62u1x+nSPPlZvSlIjtZtbYUN21rDPUedSQ0ZEsrqIiTf5nuq7WJZnVh5C4JQOZWjGLc6HliS2qXG6rrZKo2zjsK7c6T31uV1yIoNgSQLecmrHGVclSPvVlz3FLVDF7W7ZgYVHuDoUt3Zre5HP/qRSkrGjRsHdXV1qgfp5z//uZLJIZgYIcOGDdNeh7/Tc/h96NCh2vP19fUwaNAg/xgb06dPh8svv7wI70oQhHKpHMX2HBmJhwseD5LGJnwJJlykhsDkCDfrzIHo/B65rI6kdR2unqOaaEOGOJUGvaWoflj/dy8h5NekjUyR1QmCIORSOWJ5S7C02yF5XNJBe+o1mUzIkIGSJX6vFJSo32jKmIHq+9srN8P6rbhDFy2rc91TpBwjQtcdki5Y5xyV3hGoVNx3331w1113wd133w1z5syBO+64A37zm9+o78XmkksugY0bN/pfS5cuLfo1BUEoUeXIl9VFH2+aHbjgPaxxVXytHzbT6ceSpoY6/zF+PR5ruKwOWfTxVsuIiU71M78LWz9svI15CkMGLTZlv1PMlSGwgiAIlmRga4whg77zFX3upE2vuFuFx1DwcQ3a49ej+yCnur1H9IPlG7ar3z9Yu9XZc+TL6lw9R1GGDFFzjoxki7/nsJV398uOLrroIlU9+spXvqJ+nzhxInz44YeqqnPGGWfA8OHD1eOrVq1SbnUE/j558mT1Mx6zevVq7bzt7e3KwY5eb6OxsVF9CYLQfaDNN0pQkhoAxc6rY5tvcZJvXlhqZ7GpsaHWqmrgSdnqzdnYtGP/JhWXsHI0oFeDtX+3NqZylFRWZzdk0H/nx+DPmQ7s8w0PLy82UjkSBKFsMQNOnCFDUl13mp4jc54E2WGH5ipp1wYtORrev6evA8d7dPVGBcmRawis+z1louYcORyBss913aC9UrFt2zbVG8RBeV3G+28ALb4xwcG+JAJleNhLNHXqVPU7ft+wYQPMnj3bP+bpp59W58DeJEEQqgfaI6ONp6TVk/ieo6DPx9ajw+FxIqPJ6uq0c9HltMqRJ6s7aOwg9X3Rmi3GPYL/wrieo3hZXZQhg7EuR5gFxf09ColUjgRB6DaVI1MWEAUNzEuSHOExreRWZ5yY5Hk2qRxWi5ARA5qg3pMjYADjQYifj2KHS1YXFYCjAojLEUgd78/KoAGx0O044YQTVI/R6NGjYa+99oLXXnsNrrnmGvjWt77lB+Hzzz8ffvazn8Huu++ukiWcizRixAg46aST1DHjx4+HY489Fs466yxl993W1gbnnXeeqkbhcYIgVGPlqCaVY5t6bcSh7Tls2mVfF8QV2ogz5XR0XYyTa7ZgRAM4aJfB8ODc5VlZHb9HCGKo7laXXlbnW4Lb+mETyOro/KUUNUhyJAhC2WJWSkwzBJP2NJUjqpQk8AfllaOwW53nFGTtOSLpQk+mTcfKUdi8QUuOcrDy7ojYnQsFoEgr7+6XHaHlNiY7//Ef/6GkcZjMfOc731FDX4mLL74Ytm7dquYWYYUIrbrRurupqck/BvuWMCE66qijVCXqlFNOUbORBEGoLkyTgaSzfrKvjdjkSlHBd5kFUc+RuXFHMWL9tlZ1P7jU7zt6gHrsow3btb6pDBoyFMytDiJ6jvTf9Rl8Zj+sVI4EQRBCAadQsyT4gtuQsHKUvX7YkMGULtDPGFhW+slRE0uwMhGGDNGyuqiEL40hAw8y9JQflLthctS3b181xwi/XGBSeMUVV6gvF+hMh6YOgiBUH2u3tMCH67bBfqMH+msx3/SKgm+eRR1J54lzqkP4so7np1jEJdw2Wd1qT1I3qFcP6N2j3l//zepWxvuVb5jZVA1xsdZ09uPw0RMu4yDpORIEQWCkDkDG80nmSSTboaO5EUFzqHlNzWShsxPWbm2F1o6M2nUb1q9Jew/msURtnKwucs4R3Wu8IxAPQjxpU/cgUUEQBCHE+ffOhZNvmAkLV25mc450CVsyyXe8PDpJXMKkhdZyTG5MWR3FC/pO90D9Rjv0bfRjjblpl2FW3rWFmnNkqxzVuBUOdHhXDCiXMCgIQtmSCQ3ag1TJUaQMLZPMylsdwwKQKatzWXnTjKMhfRqhR32t1nOkGTKw08W71UW9H3eyF7JLLRPpgiAIQqVAMml0eqP1ntbqKCdRhIeNJHOOkvQc8YSCGwW5rLzpFrXkqNbeC9vpqR8Qfie2IeNJE8O42GRWhui9kaqhlLFJkiNBEMoWWnQbvAU5jawutnJEc44SlEpoAcfrm7I6PwAZeu3l3oyjEf2btHNgNUm7D/bCwJAhvVtdpJV3ZM+R/j66Y8+RIAhCvgQbYYE0ri4nQ4bCKBp4EtXcHji5UuXI7zkidYN3XZpxlE2Oguvwjb9OCGR2miGDrXKUUFJok8Xx9+mSfweVJygZkhwJglC2+LtzdckCkOkklymQK1AgPbBVjvTdOfqZ+o2Ge8kRXafNsALnr6PExD0ENkdZXZSVN92X33PkvIQgCELVQms3JgO+qoEqRwn7buKOpUTANmzVBq3fLW1BXCErb19O16knMas3hWV1ZvUpoypH3i9cVpdDz5Gf3FjekqZicCRHbSkTxkIgyZEgCGVLsDvn6brjKkeh5Che2+2q0rgqR2YC1uFwq9velt3J69PYoF3HrBwFTj7BY66ELapyFildqEsgq/NuRGR1giAIYVrZRhhVf5LGpo4i9By5KkdN/hDYjFVe51eO+jRqSVgLS446HUNg63OR1eVoyGCaBZVS1SDJkSAIZQsFoIaElSPz+ch5Er6sLkXPUSbj76718IJK4FbHgl+GTwXXz2EOkbXJ2dxDYCPeTwq3OpHVCYIg5CGr89Ziik1JE4RC9xyZlSNcvinh8QeUG/OONmzLzjga2KuHdh2eHGWUdDDcc5SPIUNdSkOGsKxOkiNBEAS/j4dK+bxJNJFbHRRmh452t7KVo+xNNXq7c5Rk8YIQJmlmJccPYmyHT71HX9cdPOYKjJFW3lG67ghZXVi64LyEIAhC1ULVdVxrzWpIGifVJL2wSStHZlzB2EFKgYzDkMHfGKyr0a7DkyOEbpMnJaYKIc4oSKtApTVk8N3qSj+gXMKgIAgVY8gQLy0zX+8+N0kOUrnVYc9Re/akPR2OQPSzaZDg9xw55iTxig0GEVsgiHrvga47WrqgfufBzpfVlX53ThAEoVKgtRs/8Hem7DnSB6xGHZdWVpdd25u9yhH+7q/pfmzSz+0bJNTWaHbgLlVDLQsfPBYH7939hvhTcWZB5nsOudVJz5EgCEJ4CnmctI47v2VfX2C3OrTy9q7Rs0edJrXQNOXYsGsEOeo5Mnfn6Dhz2bdru933SH8XW9XJrAbpTbDZ72LlLQiCYAcTIuoXxaUyqBwlnHOkDYF1H9uWYtOOr9+8cmTOBQxZehsyN7qWqWro8AOOPYHBERXmezPh8boubXJEqoYu6IeV5EgQhPIfAss+3UeV8ENW3hHHppHV8Z4j2j00K0f80mrQq6Ny5ApA5sJvdwWKCEIdKSpHWs+RHkglNxIEQdDhRjy4VpqVozSyushNLl9Wl+zjOW2i0aZbViqnj76gOOr3HlFs8u6dqkFm5SgTI/kOkiO3VJC/b9tb0iR7DkMGsfIWBEFgdFoW5CR21sHr42Vo1FAbBS3aGCBJd06D9symV3VulNX5LnR6z5FTumDchi1pS7JDZ9udM6tJ/Hf6kXbnSmmXKgiCUAnwEQ7Krc6LLbwfNoqOxHOOcjNkaPbcUXEjkfYSg8qR/rtZOaI+IlPV0G7ZMOOSb+5053pLPGbFmQW5KkddoWqQ5EgQhIqZcxQnqzN376J26NIkA/6cJTYElipHJOXTgx+XXYCWhJlzkuh1pkucbc5FMivv8HMhFyBLE6z0HAmCINjhvaLZ9d2oHMVkR50p3eoSGzJ467VfOUJDBq9EY27c+b1HhplEvatylHGoGrzjybGVX8P1fmznUY9FGTKwTUnz2GIjyZEgCGXFxu1tcP+rS2FTc5u/mPMm0Kh5EuYCHV1lStNzFDjTUXJDPUeUVPDgp2R1xoIeVzky44YtOEYGVUMDn7RyJLI6QRCElJUjY71NJ6uL75vN1cobN/J8owSbWZCKTaDL6mJ6jmocm4WNnqxOHet4T1wGHzegPGzlrd9HKUUN9aW7lCAIQjx/nvkBXP3kO7B6cwuMHNgzXDmKCELtOQ2BTd5zxK28g8qRLl1QP3OrV7/nyGHIQJUj45oNaWV1aSpHPCD50gUZAisIghCfHIUrRwgmTK45cWnd6pIMJ88e58nqvMQGNxLNiosp+XYZMoQ27jrtqgZKcqjnCHGFpjhDBh5/w0Ngo38vJlI5EgShrFi7tdUfVMdnSfjDSqNm/ZhRJyIIUe9Qkh26OouVd1TPUWfEnCMzALlsSvk8iSRNv1GD8kKVI3Zuesp3BpTkSBAEQYPW/XDlKNnGnRkfCtVzROs9VY7wfsx4wW8LH/ONFvwB5dFOqrUhWV04OUokq7O8J22jznjeTMrEkEEQhKpFs0vlJXlvoYxyq0vTc5SLWx3ORiKr1SZvCCzNS+KJGb6FkFudY3cucAQyeo6YPI67AuWiVTcf0+YchfqR3NcQBEGo5rjkzzmybDQlWZ+zry/knCNdEpc1ZDCSI+PapnmPc85Rp11qTVUt3hfrSgzNYbnRQ2D158yXuKpyxUDCoCAIZUWbt0BnHYHATxxoVynSkCGHniOb8UFk5Yh6jqhy1GHfnaNYGjS9egHINGRw6Lp50KB7jHo/vnlFjK7bPLcZcEoZgARBECoBPkMPl/BgvY2vnpjPZYriVpfx+4d4vIqU1cXM4OvwHVfBXjnSDBns92ezA7fdf/a87pET6ndJjgRBgGqvHPHyfw2vHCWX1bmCEO785VY5QivvTt2QwZg6TtcNy+ocAcih6+aa8yTD9qLsTs2+Km0IrGkEIcmRIAhCjKwOUsnqtMpRxHU6Uo5UqDMqR/h7UDmiAeX6fYTmHDkNGTKO2GTrOYqW1bn6hXRDBoiW1ZUwY5HkSBCEsoIqM3ywnKocGc41SQwZnE2i7DguX3PBrVEpefN7jvz71YOnKasjgwW3Xap+TW3YnpcoJbPyjtZ1q98jZ0s4LyEIglCVmLI6myFDEqVCsSpHtOmG8SywFwdHP6z32tgZfGCX1dWmkNUZCorQ/Wu9tXosFlmdIAiCR6u3Q6eqL53BophEVmcGHdehPInii3OqypFpyGBMUDfnDtF1QoYMDgttXu0hy9QkVt62ptckVt6u3wVBEKod063ON2TgPUcR/bD65pn7uEDRkNCtLjQENlw5yjjGTNBxtEHo6oetMUTf/usS9FtFDSc3H49yVbX9XkwkORIEoUwNGQxZnTG7IZkhQ2dscpTIrc4LAlFzjvilbZUjV89RnCNQ0p4jOq215yjSyls/Vqy8BUEQ4uYcWWbwRW7csV8SGDIkrxzpcm0uqwtik95z5DILCvccdXrH6deke+PmD7GyuhwMGUK9spIcCYIA1W7IoJpes4/V8J6jhI5A2WMdCzabdl6f1q3Oey251QVzjgy3OkfPkcsRyDWFHGmo192HrO/J2yW0BRAzOeLv2bxuwvEagiAIVQMlGsGcI/rQHxzTUQhZnXedJIoGdZx3fV9WVxfI6ug62owljKsOQ4bEsaku2PDz5e6dBXCrM6plZigTK29BEKqWoOdIaRfCbnUpKkeuI8mOO7khQ5AImUNgKSnhO2e86mVKEFy67tA168I9R0ksYG07dCHXn8ieI6kcCYIgJLHy5v2wkWZBCd3qKJ4krRz5M4o8WR2u58Fg705rbPKlbv6cI69y5FA11JgVHe+a+DqSYTtldSkMGcyNOfM10nMkCAJUexBSlqOdwSIZVI4iAkuo5yi61J8dLpsgOfISFXwdVbYCQwaLWx3TddMCb7oK+cdadiBdsrrofitINOcIf+Tv2Xz70nMkCILgltXxQao1bI1PPOco4jppXFT5cUHlqEaLV+a1ec9RSPLtkNXVhGbwBXK8OBfZINba7z/SHCiULEHJkORIEISyghZojD1+AGI9R0kc2/zfOwvrCKTmHGUchgzsWkrX7ZhzRLI8/16838PytnRW3kmHwMZVikRWJwiCEGfIEHy4TzSDzxjEGrdxl2T+npYckSFDLfYB6e6mZj+sKatzXSvDEkDbNbNVKv1Y1zlc/UL1EbK6cGySypEgCFUKl9XxyhGtm0kDEJ3DBtlvJ5cusMqRachgldWFg0J9rCOQToNFVpfEjMIWhHj/Upx1t8jqBEEQdPimVtaQIeUMvpROqmkrR81eXMFYRfcTJEdG5chhyJBUEtfgxSOMK3FVMz+G52DIILI6QRAEU1aXCQKQZsgQlSAYTxU6AKF0gc5pVo60hlsuXWASBP7+4gIQv7egcgQ5Vo7YzzH2qCKrEwRBcFeO+Jwj3NaKq56k6YdN61ZHx23a3qa+926s15QO5n2pjbuQqsGeCrQ7e46YIYNh/uB6P65NN805NXbjDkqGJEeCIJTlJHLmx5DCkMFelclXumDOkuA9R0r+pzTo+vm5DXlUIuYKQPzekkgKXc5C2ddHVY6iA5IgCEK1Q72mvqzOS29wvUwSm8yn3GMmAkvuJNC1KY4M6NXgb8TRRqJrzIQp+Q7fc6f/Hjl0PDrqxZlRxLnV8aqVeR8y50gQBMEqqwtXjqJldfrvrkPpGskrR7XO5EidL5PRgoMKQJmEAcjR9Mpf5894ijJkoB1Hi0RCdwSKToZKOUtCEAShEmV1tA+nBpQXcsxEjpUjon/PhpBbXSbOkCFGVlfjsPLGGU9x7901K8mW8IQNGSq05+iXv/yl+qOdf/75/mPNzc1w7rnnwuDBg6FPnz5wyimnwKpVq7TXLVmyBI4//njo1asXDB06FC666CJob2/Xjnn22Wdhv/32g8bGRthtt93g9ttvz+dWBUGoEKgnJ9Rz5Mvq3K81A06hA9B2lhxRzxGdz7RqDTsC1cZUfOw9R9wRKMrKmwKhvXLkbnqNC0iCIAjVDpdDY7Kh9Rwl2bxK2HNESZi5Trsw1+8BvXpoPbLmtXmSFmvIkMl+N0MKxTJlyBDz3k3zh2hDhuiNu1Lu2+WcHL3yyivwxz/+EfbZZx/t8QsuuAAeeughuP/++2HGjBmwfPlyOPnkk/3nOzo6VGLU2toKM2fOhDvuuEMlPpdddpl/zOLFi9UxRxxxBMydO1clX9/+9rfh8ccfz/V2BUGouJ4jvayf1hEoSc8RDb9L3PTqJUf4K5kkUEDj98Xv3Xf2qYupHBmWDFwPTjt3kVbeEUGI7wyab9ncFZTCkSAIQvQQWPpN27hLsD4TrkPTbtyZlQWD7CoAALRZSURBVP4BPRtCMmweF3nvVGAWVJNKql3He468p1ySwii5t3pcM2SocFndli1b4NRTT4Wbb74ZBg4c6D++ceNGuPXWW+Gaa66BI488EqZMmQK33XabSoJefPFFdcwTTzwBCxYsgDvvvBMmT54Mxx13HFx55ZVw/fXXq4QJuemmm2Ds2LFw9dVXw/jx4+G8886DL3zhC3DttdcW6n0LglCm0OKtBu2xhZU+1CdxbIt3q0tZOfKSi+1tniMQm0JO1w3puh2zJJL2HPHdOf+9J5jxZJPF8aBiVrBCgU+yI0EQhAgrb10pEJcgqOcSqhpSmwUZm27YcxQ2ZODvg923Fwrq4mR1oEOVpob6QFYXl+y53k9dpCFDhSVHKJvDys60adO0x2fPng1tbW3a4+PGjYPRo0fDrFmz1O/4feLEiTBs2DD/mGOOOQY2bdoE8+fP948xz43H0DlstLS0qHPwL0EQKgueZHBZneZWl8rKGwrS9GrOksCqkZpvUROcL6Tr7kzmCOTaWavXduf0BtvIIGQJdDwxixusJ1begiAICeccqY27eMl3qB/WeRxtwOXWc6QMGfzKUSBRt70PX1bniE0ZR2w6Zb+d4KCxg2Da+GGxVbO8DBlCPUdQMurTvuCee+6BOXPmKFmdycqVK6FHjx4wYMAA7XFMhPA5OoYnRvQ8PRd1DCY827dvh549e4auPX36dLj88svTvh1BEMoIPgMIkwtab1XTawrHNqIzrnKUo1sdLeiY8KAMEM9n9hzRtekSrmAXGDIY16yz6bohpzlHPDCFKkdGAJLcSBAEwd1zxK28cb1MJKtLWjnye45yk9X179kDNje3OXuO+PuIM2Ro9+7FjAmf2G2I+lLniJk/SJcrhJV32c45Wrp0KfzgBz+Au+66C5qamqCcuOSSS5Ssj77wXgVBqPQAxJpec9F1Q4F03V4E2NbaoQ/B84IKdwCi+zBlda5g55oDoVeO9GOt56G/lWVV59eOqxRJ5UgQBCFaVscl37kMKO/MFDY2cbe6qJ4j3jsVa8jQaXer4wSyus7cZHXdoecIZXOrV69WLnL19fXqC00XrrvuOvUzVnewb2jDhg3a69Ctbvjw4epn/G6619Hvccf069fPWjVC0NUOn+dfgiB0pwBECz4kl9U5konAkCGddGHDtuyOXN+mem1hx/vmsaEjjZW3a5ZEHZ8lER2Asv1Z4Kwc8WuHe46gy+xSBUEQKtuQIVhzXeuzfeMuJjYldKvjMax3jzo1MNzsOeK3ZTNkiN+4AyfBpqX9ee7qZ329FpuiVQxlOwT2qKOOgnnz5ikHOfraf//9lTkD/dzQ0ABPPfWU/5qFCxcq6+6pU6eq3/E7ngOTLOLJJ59UycyECRP8Y/g56Bg6hyAIVSCrY/1HStedZM5RSLpgP67dCxDJd+dqtMoWOgLx12d7jBxudTFW3hTAwFk5Sj5LwnUdLleIb3q1X0MQBKG7s35rK6zYuD1S1cBHN3BZXeTGXcLY1JFy444nF2jjzWMA3aPLrY5iQZxbXU3E9WvydKuLMmSIqySVTc9R3759Ye+999Ye6927t5ppRI+feeaZcOGFF8KgQYNUwvO9731PJTUHH3ywev7oo49WSdBpp50GV111leovuvTSS5XJA1Z/kO9+97vwhz/8AS6++GL41re+BU8//TTcd9998MgjjxTunQuCUPZNr9oQWL/pNYV0oUCOQGbwGEhByJMj4Pm43A+v6++6UQCKcQSqjeo5ikkM/QTLIavTZ0lATM+RZEeCIFQnJ984E1ZvaoZXLp0GvXrUW13eeKU+cT9sUifVtGZBbL1GSR2PAYFbHU+OwrHPPeeo0ztfvKwuUwpZXQl37lIbMsSBdtu1tbVq+Cs6yKHL3A033OA/X1dXBw8//DCcc845KmnC5OqMM86AK664wj8GbbwxEcKZSb/73e9g5MiRcMstt6hzCYJQHcmR1vQKuQWguJ4jV1AwMRf2/r30ypEyZDDc6uhXf85RrKzO3XMUZ+XNH7ddR5slIbI6QRAEK0vWbVPr9/ptbXpy1O7YuGNraJSsznyqUAPK9coRxaXsGo+XwLhkc6vjiYhz464zvnJE13e99Ti3Oi05Mu4jzlm1rJOjZ599VvsdjRpwZhF+uRgzZgw8+uijkec9/PDD4bXXXsv39gRBqCBaDFkd6bLVEFgq3xfAEcgPECnnHBEDelLliLTdGU0m0ZFizpFrloSfHLGeI1fVjCeFNumBVjmKNWSwXkIQBKHb4zu8GWttuB82PAQ2jeTbtXMXVHbS9xxRcsTjGl5Xn3OUfR/89M5+2Ey8msAfUO6MTRAtq4uoHNVUiiGDIAhCMeHSBW2WBFZPUsz64ecohiPQQGOHLiyrC8sJXLbhFIBCw1h9WV12plLU++HzNWzvKdLK2zhcZHWCIFQjvPJjbqy1ZczYFGx++ZJvd2gqWmzicQNtvEPJkeGkSn29WuXINYMvE8ja3dePUTWkkdWVUc+RJEeCIJSvrI4tzr6sLtIuFVJNIU/sCGQZtIfURcrqTEOGmkiNubnuN6Sw8qZz8HtyN73qz4mVtyAIgr6+mmstl9U55xw51mfb45ki9MMGsroa7Xw86aPz16aQ1dVGxIQ4WV2sIUNEchQeOwElQ5IjQRDKdAis3a0uunKUbAw5udWZGmcX5qIduAIlkNV5q6zTLtVuVqf1KsVZxfra8Bp75Se6cmTs1klUEAShCuEbb2aYCcnqwLJxF+PYlqwfNjcnVe6ialaONFmdF2N5H6qr97YjgZV3vKyOkj3763n8MWOkyOoEQRAMu1SMEdoQ2CTShc60laP0u3PaDp3fc6RbefMmWH/QXm2MI5Cx8OO8Cro2BYk4WZ1txhGCr6f7CFl5x1SSBEEQqgG+txaS1WlW3sFarNzqYqRltsQhbgZfYrc6S+WIxwFTVmfrt42bc1QTYckQK6uLMWTQnVSjkyFJjgRBqEp0R6BgsU3qVpdJrevOza3ON2TwXt+BsjpDr24aMriqVBQMzXX/4F0Gw6RRA+Dk/UbGNvzS41EB1SXvMwOO9BwJglCN8DXcjDOtIStvtnEXY2dte7yzCHOOqOcIYyUt41lVQ2foffB1v8FxrUyCnqO4IbCuzT/b/Zube+GxE1AyJDkSBKEsK0fKhlQLQBAZgNLNkkhbOdKXSlPbrQKQplfnkoToniNX8BjWrwn+79xD4AtTRvpBwimrs8yuMPErRzG7ca7qkyAIQvXI6rJ9pHOWrIdtre2+FNvqVhejauBxiRIRkuWZYP9qKrc6dhzFpezjJEPX46AvKdfc6mpj5No1uc85Yn+nqNern8uoclTwOUeCIAi5okkXVM9RsDgnmnNkLNCuPMoPQDn3HIVldfy2VGBNOOcoSQCK1XUb5g9R7yGuciRW3oIgVCN8gwuTimcWroYz73gVTj1otHtAOVszXeszl+vhOoyurIVzUgVrcpRd1ztD/bCp5hxlkvQc5edWx69tvmfpORIEQVCyOmPnzmLIEO1WZyZH0e5u5AgXh7mA92ms1628O3RdN9d51+U454gT128VmD/EJ0dxjkAiqxMEoSuIGqJaCrQ1vLMTVmxsVj9/uHabMWYiqPvwfs4ksjqKGbGqhsQbd6xy5MnqstcJNtR40ufL6iJMeohgcxJyj00xbnVRhgzh2AQlQ5IjQRDKhhZDVqfpun2ZQBpZHcQ0vabvOcLdOUogfCtvwy5V9RzRvdeGg6jtnqPyNL/p1bUz2Rm/20jPhQJQTEASBEEoNv9x12w44Q/Pa/K1LpfVeb9vbmnXzYKYrE6z8o7pCU1kfZ3Src5m5c2vw8dK6LK6NJWjGuf1kw4od7nV8fsIO6dG/15MRFYnCEJZGjJkd7zAYpfqfr0ZnOLcg5LuzvEA1N+zS+X6cQxoNr26zRXITOBSBSDXbqNlNzB0DmflqOsCkCAIAvLkglWqOrNyUzOMHNirS+6BL6+4ftPavKW5zXCrCw5UPUe+7Bli+kqDzSe3qiHdxh2t6431tdDUUGdNjnhsssnqnE6qnZBA8p2nrE6rYImsThAEIYR7lgQbhJpGVhdzncS7c2zba6A344gv+KaGnAckPQjV5CRdCJIj+/PmwFnre0goqxMrb0EQSg0lBeaoulLikkZvbenwN6DM4/QxEzE9oWqgd/RaTtdJWzniVaPstTzJN9tkRNpssrqYTcIaKKKsjleOZAisIAhC9BDYrFtduiGwFGCDc8RUjvKULlDSZOq6Mffy3Yxi5kn4PUeRlSPv2Jj3E1X18S3FY6y7JTcSBKGUZK2x4ze/ig1PevBHupUthqyOxxk1ZiJG9szVAbS+utzqkqzlnKF9G9X3MYN6a49rPUealbfFkCHmWrV5yOriKkf8PszY1JVjJkRWJwhC2WBKF7iVty+r60wz5yiu6TWXnqNw0yvet6brZlt1uitQbU49R4FOPX5n0gXtDpoOfV2p6xYEQdArNl1XOgrNqvN+x+SIfy7n91tTG3yId8Umf0g3H+jteJsUO5Ju3O0+rC/89ayDYechuhQxrudIrxzpcam+tkZPAJP0w8bEpkRzjiJiU6njkiRHgiCUDXzQnjlLIknlyAxOzgBkaUpNXDliPUearptdi0swYitHviVslK47uE6uu42+W12MdbfI6gRBKCV83e5CP4awNJo9wEOLlhwlkD1ziXVUMoGxzRwBkYSpuw4OPcbNgjossjp9zlE4KWk3pIMuYt87SwzTDoHlv5Z6z06SI0EQupz7Xl0KO/Rt1GR12iyJBLpu9VzCnqO0Q2BNtzqzkdV0q+MSDP5aW89RYMNdACvvqOqT4bDnli64zyEIglBo+CZW1By70srqdKk0R08cmJV3nKwOK0cRm2A8SXTZayfFHwKrNhmjZXUNRuWooa4WWlgsjuo6iquaccdZG5prXkRsKvWICek5EgShS/l4cwtc/L9vwPn3zA0ZMnC3nCRudaa8LN6tLpcp5MyQoc4uXeDvQ9NUWxpfMyl6jnLVdfPn4pKj7lo5+uijj+DrX/86DB48GHr27AkTJ06EV199VQvil112Gey4447q+WnTpsG7776rnWPdunVw6qmnQr9+/WDAgAFw5plnwpYtW7rg3QhC98F0+iw3WV3oONOtLuGco6whQ/hatuQs6YByF3RPqGKIk9XFSatroypHtcn6e11OqpqVd8R1S105kuRIEIQuZWtLu/q+cXsbbGvt8B/nO17KESjGztrm9OO0S+0oTOWI7klJFzpdsjqI3A0MZHWQu5V3AvtXZ3JkvKQ79hytX78eDjnkEGhoaIB//vOfsGDBArj66qth4MCB/jFXXXUVXHfddXDTTTfBSy+9BL1794ZjjjkGmpuzgyARTIzmz58PTz75JDz88MPw3HPPwdlnn91F70oQugemS1x53Id7M8rsx/ENc2Lm0OFxfs9RZ/R5k8YmF9yQgd+XL6vTKkf6tRqM3/OacxTjpKptHkZs3EU5sRYDkdUJgtCl8N25dVtb/J9xseU9R0HlKEJWx4ahtkQOgc2958hm5Z1JWDmyBTySlCSbcxRXMYt/D/GVI+h2/OpXv4JRo0bBbbfd5j82duxY/2dMon/729/CpZdeCieeeKJ67M9//jMMGzYMHnzwQfjKV74Cb731Fjz22GPwyiuvwP7776+O+f3vfw+f+cxn4De/+Q2MGDGiC96ZIFQ+WlJSRpWjOBmzL/mOGwJrc6uzVY46Cpcc+f2wrHeXx6YoQ4a60LwhSCCrg9zc6iIqWDw2lVrRIJUjQRC6FL7jtHZrq2HlHa4cJZlzRIu9ewp5p3WHzIXSiteEh8BSAMvOkojvObIFCErUkkgXYgft1eRvyFBqbXcp+Mc//qESmi9+8YswdOhQ2HfffeHmm2/2n1+8eDGsXLlSSemI/v37w0EHHQSzZs1Sv+N3lNJRYoTg8bW1tarS5KKlpQU2bdqkfQmC4Oj16cLKEe99UkNgYyr1iOoiiptDx0wJoja6NJfTQiVHxoDyJFbe9YacIHrjDhI5qSZyq4uITaUOS5IcCYLQpfCFe+2WVu3xwJABm17jgyc9RUmPK5kIHHuSL4E9venjQ/pk50roPUe6lTftzuGCzpMNPmwvmCxOvyepHOWm61b3mrByVGr5QilYtGgR3HjjjbD77rvD448/Dueccw58//vfhzvuuEM9j4kRgpUiDv5Oz+F3TKw49fX1MGjQIP8YG9OnT1eJFn1hBUsQhAC+rnWprI7fR4QhA7cbzw6BpcfjE4SoZIK7jua7SVXn7DkKV3JCyVGduWPmvk5cv1WcWx1/OCz5dvcjFRuR1QmC0KXwgLKOVY64rCErR4iX1QUVIaocxRgypFhwf/q5vVTyNrx/k73nyGLlbSYaPBnDa1OSlli6kMn9/VSzIUMmk1EVn1/84hfqd6wcvfnmm6q/6IwzzijqtS+55BK48MIL/d+xciQJkiCUn6zOHAIbt96abnVx8YZXjmxHtqUcAJvUrY5XxNpyMmSoSRCbcpPVZTc+a9TfSHqOBEEQPPjCvb2NGzIEsjhu5Z1MVhctc6AAEdohi+BL+49yByDDytsWgEwrb5QutHUE7zfK4jXWyjtGusDPUY1W3uhAN2HCBO2x8ePHw9/+9jf18/Dhw9X3VatWqWMJ/H3y5Mn+MatXr9bO0d7erhzs6PU2Ghsb1ZcgCElkdV13H3wNj5LVmT1HwcYdxLrV0TJvq0pRz1G+/UZ8XVeSb0ts4qEP7x/VFm2O69dEXie/IbDZe6mBDohOjsTKWxCEqiLKLtXqVpegckSa6UJWjmxQJSjrVsd03d6MCPP00TMdIGcr72RDYGsTNdt2x8oROtUtXLhQe+ydd96BMWPG+OYMmOA89dRTWoUHe4mmTp2qfsfvGzZsgNmzZ/vHPP3006oqhb1JgiAUQFZXNpUj3chAO449oSofMf2wfA5dkp6jglSO2JgJfl+BpNzdZ1SXoucormoWVI7c90qXizIHEitvQRC6PfOXb4RfP/42bGlpj7Q/5T1HvltdROykIBBICiBn6+skcK05v5bNLlXdF9uuM6tWydzq3H+r7P24z0F/E9s09KjfuwMXXHABvPjii0pW995778Hdd98N//M//wPnnnuu/9/X+eefDz/72c+UecO8efPg9NNPVw50J510kl9pOvbYY+Gss86Cl19+GV544QU477zzlJOdONUJQu60l4khg9ZzZFhgc0g2TUt2nCkBl5b5x1qEdYXatNM27jocbnURsanBiE1R+2VJq2ZR8a13j6yIrVePbF9vObjViaxOEKqIZ95eDX+e9QH88pR9YFi/oHem1Pz+qffgsfkrYY9hfWGnAT2tx2Cc4D1HtF5HGjIYbnXuuUDpZXVRAUglR+y+fAe6FLtz+dil2ppsXeeI6zHqhrkRHHDAAfDAAw+o/p8rrrhCVYrQuhvnFhEXX3wxbN26Vc0twgrRoYceqqy7m5qC/5/cddddKiE66qijlEvdKaecomYjCYKQO3zt7CgXt7qIIbCUzPlrasyYCS4to1PaTl2oTTt1jprwWAn+e7hy5O5BqqnJR1ZHx7lP8rOT9oaPNmyHEcZngai+qGIjyZEgVBF3vbQEnln4MTy7cDV8+YDRXXYf27zeIhz6msRgIesIFF09Ucd7z9HOl+vQtENgkwzayySSLrhldZFudTFTyP3KUcQ53HOOur+VN/LZz35WfbnA942JE365QGc6rDoJglA8l7jymHPk3oijx2ntDOYcuc4bJAgZr2Jki2PFqByFkyPv3kMOdbpZECeuXyhp1czFcRODPk/9usHPYuUtCELRoIWSu6R1BWSFauqh3TOAkg2BNRtabdIFfg5znkNa6J6ybnXha4Xd6qJkdZCHlbd+PzaO3Xs47DKkN3xi18GRyVB3lNUJglC+dFSarM57nEx04uysdVldTYLKUQF6jrxztDpivRmbTLMgTtTd+LK6PMZMuBBZnSAIJYEWqq6ULpj3EeVORM8lmUKu9Rz5sjr7cRSE8pXV+ZUjR/NueHcuqnIEOduldiSoHJ20707qyySukiQIglBMeAzo0sqRYcgQZRak9xzFyOpYgkDxy145yqQaTh4Fretm5ch83lo5qjNiQgK5dpyTai5W3PwlYsggCEK3T44oGMZVjtq8AzVDhkRzjqITqUK5Avn24h329xEyZNB6jlJIF+LmaJCOPIegWlsFbnWCIJQvZsWmXCpY5nJLG1p+5agmnZ01Ls+RlaMEvaOpkyPPOdUkZMgQ1XMEUdeBhFWzZPetn5tVjkqcHUlyJAhVBC3+UdWXUkDJSXZAXcKeoxhTAjqfbuXtOK93koY8ZXU8WNr+ptE9R8ntUukpd8Mv5LE7l7yCJQiCUGwL7fKwFA+vt431gQEPX7P9fthModzq8v9oXh9bOTKOZxtrdaGYkKBylMCMopJkdZIcCUIVQQsVt07tmvuI13XznTQ+hTxJMhUYMtiPLdQkcq41t92WGeOieo6iiJMUJml6dZ67Cqy8BUEoX3gMcEmHSwFfw21DYBsb6kK9sPx7oiHdfjJR3J6j2rieI4eTKj5ek2LDrCbuvefxnmTOkSAIJaG9bGR13n1E6Lr1IBRfPcFEiJ6ihT5uwS5Uz5GqHCUwZNB13ckrR0ESBkXYnTN/l+RIEIQqNGQwKljmvfQwellrQqMWonuOeOXIttFVqBETSSpH5jpPG4oYs2pSxIRYWV2CGXwueJImlSNBEIoGLfZdGYA0eZ8jqSCCCldQOYoLQDy4OHuOvICRr2Wqf0+ZjPVa4TlHbkOGaLc6iHGrIzlGftIFRHIjQRC6Ts5WLrK6sKqhscE+m85PECIGmofc6qBEPUcJDRnod7y92lByBLnL6gwJYhr45qIkR4IgFA1KNrpcVudXsKKDIZ8nUZdQ24w0JHWry1PbHSRH6a280w3ai0728rFLNa+bS9+SIAhCYWR1ZVI5Un2k+vNN9VlZnVnZqIldn7PfcR2n1bWz6HOOPFldUkOGOiarA9OQIaofNvmMp7Tw8FyANqxUiJW3IFRj5aiLDRkokbHtzrkmkXd6i6PbXjX42Q8uMRPOc3F3cw2BtV0qzRDYSFldhE6drp+9Xoqbp3s0riuyOkEQSglf07vWkEH/2bwXs3LkD4H144DrvMEmX1R/UiF7jvzkKGHliMvqao04EhUSkvfDprh5/7pdVzmS5EgQqgjSNJdLz1F2dy6BIQMurJnklaPYOUdewOCD7/KZQq6GwNpkdSl6jqL8Un0zijhdd56OQLbfBUEQiglf07syNpn30eHoOSJ8tzrfnjveMIeWV9uhxXGrS2fIUGurHNW4r5PUxjxft7oox7xiILI6QagiaK3v6uTIN4ZQlaPwYku7WME8CeZW5zIlYEEgas4Rl0vkP+fIu3YOVt5mYpaPlXew45h+STcvWyNRQRCEapTVGRWsuMoRrZ3++pwgQaiJNGQovFtd2jlH3PwolVmQq2qWj5Mqu24BPCpSIZUjQagiyqVyxIfRmkGiR32tl7xg4sQsU2MSBK1yFOFWZzsuVygZUe/DcjGzByiq5ygqdsQlhvlKF/DPS38W6TkSBKEa5xyZ9xGec2TvOeK9p/FzjtwbdxTvCtFzlOucI36PBemHpcQwbytvqRwJglAkaHenKx2B1H1Qz5ElqUAzBfqA7leOEmibeWCihd82aI+keoW08s4meeHnzdNTRct27aim12IaMmTvs+u03YIgVDc8HnXlnKNO4z5ClSNvCCxBK6XvQOdSNbD1OWp99Y2CClAmoY07Z8+RQ/LNq1vJ+mEhxkW2MAPKJTkSBKGqKkfmooq6bn/BZYYMVORx7s5558GEJSpY0d+gMLK6IImz3Ze5oHPZmymBy8vKO4+eI/M+JTcSBKGUlGvliEJFrx7ZilGTNwSW8IfAxlSOaD+OzxCyV44K13NEscDpVmcaMviyunACl8TK2/XPlo+sjr+k1HFJkiNBqCJoF6dckiProL16TI70yhG38nbtUPnHsgnfNqmbNg+pQMkRXqcz5Zwjs+coquE06SyJXN8Pv7RUjgRB6LL5Ql3acxT8jGstxZov7T8KDth5IByz13C7W11ixzYem4o754iqT05ZnWPjLmvlbZKg56gIhgxRMvRiIz1HglBFkKa5y5MjJqvrsMjqaMElVzkMKEHjZ0wA0nbnwsdx956CVo46SzHnCIoiq+OBq9RBSBCE6oZ/fi8btzrWc3TIbkPgp5/bCz5Ys1U7nhKdNI5t/pQJcKsaCjnnyOVWF6oceckU5kg1qSpHkLjfKi0iqxMEoeRytnK4D9X0atwKLtJBsIHQfAi3tpk3vbp7jniVJV970NieI0cAsunKoxb/Ylp5m/cpuZEgCF2VlHTtnCN2H8wsiHpYXUYFsbI6ZphDZyi2Wx3FAlflKDxmwjNksPQc1SRQNThldWzGU1pEVicIQmmtvLvakIG71YVkdXVhzXMts/J2DUK1DNqL6jkqRNOrn7AllNXxPiNTVx4VPOKsvPOtHPE/d6nnSQiCUN1QUlBeVt7BvdCaGE4aklX2KTbwfh5bvKBxFIUxZPB6jpK61dGcI1bdSlQ5Siqry6nnqEIqRzfeeCPss88+0K9fP/U1depU+Oc//+k/39zcDOeeey4MHjwY+vTpA6eccgqsWrVKO8eSJUvg+OOPh169esHQoUPhoosugvb2du2YZ599Fvbbbz9obGyE3XbbDW6//fZ836cgCGVkyODPOcqEE7UedeGKDv7m9xzFlO/RdcfXddt25zoKOGiPzWOy3ZcZ4+ojZXXxlSNXTkvvyRxSmBR/mKGUjQRB6Eq3us7ykdX58/AM44Xwuum9PsaxjffD2jfuStdz5JxzZBsCC1GVI4iJy5CzqqEre45SRdKRI0fCL3/5S5g9eza8+uqrcOSRR8KJJ54I8+fPV89fcMEF8NBDD8H9998PM2bMgOXLl8PJJ5/sv76jo0MlRq2trTBz5ky44447VOJz2WWX+ccsXrxYHXPEEUfA3Llz4fzzz4dvf/vb8PjjjxfyfQtCdVt5d3FyREGEz5KgtU9ZeRsrU7bnCJIZMqAswLhO0QKQL6fIJJLV8R3B+hx6jlzvnXYHc91xpPuU3EgQhC6V1XVl5YjlEUpWZ8SKcEWFHk9WPYnrhy2kWx3dU1u7/Z7CsckzZGCxtpD9sLn1HPHrQPkaMpxwwgna7z//+c9VNenFF19UidOtt94Kd999t0qakNtuuw3Gjx+vnj/44IPhiSeegAULFsC//vUvGDZsGEyePBmuvPJK+OEPfwg//elPoUePHnDTTTfB2LFj4eqrr1bnwNc///zzcO2118IxxxxTyPcuCFVbOepKXXdoCKz388SRA2Desg0wYUQ/+GjDdu145VYXY8jAdd1Rsjo6jvf/FEZW537euhOWoucoyv5Vq4blXDmi60h2JAhCaeGbdV0550iX1QUmO36FyKJo4M8nGwIbnL8UG3fuIbAuQ4awciNKElcXIRPk18dNz/xGTJRx5YiDVaB77rkHtm7dquR1WE1qa2uDadOm+ceMGzcORo8eDbNmzVK/4/eJEyeqxIjAhGfTpk1+9QmP4eegY+gcgiDkBi5etHbzQahdeR98ztFeI/rBnB9/Gi7/3F6WOQs18XapbHfONHSwLdaFCUC1zJDBIqsLWXkHS26DsT0XdTdBALIHIXpPKEnMBdN1SRAEoUuMELpw4y40BNZIVkJyb+/X5P2wrOfIdlwR3OpaE8vqqOcoHIui7sbvh41JjnJRNeg9R1DeVt7z5s1TyRD2F2Ff0QMPPAATJkxQEjis/AwYMEA7HhOhlStXqp/xO0+M6Hl6LuoYTKC2b98OPXv2tN5XS0uL+iLweEEQynvQHq8cYQIwoFcP9bNZ1s8OgY3endOmkPs9OkUetMd6jmwbW2FDBiarS1E54s/h7Ztxpi3P92TO6xAEQeiqmFAO94Gxg5v88O9prbyDJCtIJjojKkeFNGRIWjny3erYEPU0scn1z0bvydwMTAIvNpV1zxGy5557qkTopZdegnPOOQfOOOMMJZXraqZPnw79+/f3v0aNGtXVtyQI5dv0WiaOQGqWhG+X6namwV+DypH9vBSY+K6bXbpQOLe6WCvvmggr7zQ9R3HviaQL9bklR37DsSRHgiBUqSGDeR++DbXfc2QmDcl6QgO5XG2iAeXc1bRYc47qXIYMVitviL2OS1ZHKpWG+lx6jipIVofVIXSQmzJlikpIJk2aBL/73e9g+PDhymhhw4YN2vHoVofPIfjddK+j3+OOQXc8V9UIueSSS2Djxo3+19KlS9O+NUHo1vCEiFunlhouPVBTyDPxtp0qOYqpHNEirCpHUY5ABZxCzoOiLdiZ19DddwxZXeTuXPCz7f37uu6crbxJNpLTywVBEHKGLKy72pAhE1I1RG8emS6f8aYErB/WcpxfOSqw5NtGrcuQwVI5qslxzAQmTL5ZUA4JX8VYedvIZDJKzobJUkNDAzz11FP+cwsXLlTW3SjDQ/A7yvJWr17tH/Pkk0+qxAeleXQMPwcdQ+dwgbbfZDFOX4IglJ+sjio3lFTQjhMvodtcgXxZXQJHoKieIz4ENl/oHHhpW8Lp0nXbrh91Ozypsr192h3MpelVXdt7mVh5C4JQraoGfmm8JdNpraY2RlrmMmTgbnWWa5lJYkGGwName943ZLBcuibSytvdC8z/LXMxQOL3UtY9R1idOe6445TJwubNm5UzHc4kQpttlLKdeeaZcOGFF8KgQYNUcvK9731PJTXoVIccffTRKgk67bTT4KqrrlL9RZdeeqmajYTJDfLd734X/vCHP8DFF18M3/rWt+Dpp5+G++67Dx555JHi/AUEoRorRx3lUTlShgyWAaa2HTo/4Ymbp6BVjixVliL0HDmfNwftcVmd8dqoM/G/hy05zKfplZ9fZHWCIHT1fKFy6X0y3epclaNU/bARPUdtBTVkiI5vLidVbhqRZuPO9tb5hmG+bnWl7odNlRxhxef000+HFStWqGQIB8JiYvTpT39aPY9227W1tWr4K1aT0GXuhhtu8F9fV1cHDz/8sOpVwqSpd+/eqmfpiiuu8I9BG29MhHBmEsr10CL8lltuERtvQegmlSOXXSpf/GyLsz8ENm4StzZLwrabVbieo7gFO+xWx5Oj2sR2qfwyUYNtc60c0fsQK29BELo0JnRp5cjoOfKTGrBbeRtGDcmcVN2S73xmApnEJVghK2/vTXK78WSGDO5/N+6Ul5NbHbuRmnJOjnCOURRNTU1w/fXXqy8XY8aMgUcffTTyPIcffji89tpraW5NEIQKcQTSZHWWQXu2RCE7BDYIKrjrZi6WdB5chP0p5LbrF1S6EH2OqDlHYUMG97l4UO7MFHaWRPbadL85vVwQBCFnuKFaF4oanG51weaRfrw5/8g5BJarIyISqUL2HJkxFH/lYd9M9Bobav0YUpPCkME3mIjYtFPnzannyP5zKchfVyIIQkVQNrpuzZBBr/gQYctUfTG33T8FFk2CF1Hqz2WxNrEFMd10wd1zZD6Xl6wuz2qY2VgsCILQJXOOyqTniG/cxbrVxRoyhCXfkT1HOW5yRcWmOKXCp/bYAT43aQSceehYiyFD/MadNdaymYJRyohuacggCEJlwHdxyskulQeOyJ4j9rzt/rkkIapJtJBTyG3n4EEpZMgQYeUdKV2ItfLOPtYjV1mdI/gLgiBUi6pB730KPvAHbnXGC4xepCSGDH7PERS3chSWzRkqBmOtxxmD1311Xzhsjx1CO3XRYybccSlwqstv0y57HUmOBEEotp4604X34RoCGyGrUz1HPEHIxDgCRTS9FrLnSMn9jNPwBCXsVhfRcxRzO1Ha7nwNGcTKWxCEah8zwTfdlKzOiE2uyhEt5c5+WFaBIuc3e89RUGnJl/CQVz3eRF2jNsUQ2CSyupxdVEVWJwhCseFBhxbhrr+PsCNQ9mf9NficJquLqBzhTpbfcxRhe12I3bnsefRllCcoZkyI7jmKvk6UK1DwnvILQiKrEwShWs2CzI07ijO0Nod6ceh7wp4jXPP9SkumxJUjY+Ms0gAIon/XruNXzdz9xbnYeKt7FFmdIAilXvjLRULh67q1XaJw4sA/99uCED2GCUKUe1Ahp5Bnz2OaLrDKUShARfQcxSz+9HyUlXeusjqx8hYEAaq9H7YzWtVgKgVChgyOPUetchRhFuQnUcXoOTLiXZTTam2KylGUhL21Pb/3E7VhWmwkORKEKoFXbLow/ujNt9wRSOvVia4cWXfdOvgsiZp4Q4YCyOrM+0Z68MpRhFtdaCcvJjGJktXRe8/ZkMEP/jm9XBAEIWcyRaocfbRhO1zy93nw3urNiY7nTnl4G1yqHVXNCKr60WMm9CGwRXarMxbzhnqzchT1WkjecxSxEelXjnLtOeKD4aXnSBCE4uu6M+UzaI+5zEVVjnhiYdtdDAJQIAOw9RxxB51CEKXtjppzZFau4u7GZReL75EaX/PVdkvlSBCE7mLI8MCcZfDXl5fAn2d9mNMwWvrVOaDckNu57j2oQPFKS5HnHBkbZaY7a+SMvprkku/aJHLvglSOynjOkSAI3UTXnSmTQKgCkK1yFK6qcNmZTVrGJRBJBu0VrueoxpnEme+jX88G6NtUD30b68NudTHxwxVU+d8zX213qaeQC4Ig5CqrwzU/qqLQ3JYNdJub29NvIDLXIr4u8iXS7NWMqxzxMRO24ETXLERsClt5u1UMJrUW5Yb7WJIUuuXehek5gpIilSNBqBLKRdetJ2mscqS51emvqTGDUCY6ANHxtmCV726WCb9v7pTH75doaqiDx88/DP7vvENDlaJYWZ0jAHO5ZL6VI8mNBEGoBFnd7A/XwaTLn4B7Xl7iPIbWxm2tyZIjfu1WprFzVTBIJBdVDTIrQoF5g/t+C1E5CjulRs854tQY0SnqbiJldXm61emJqMjqBEGoErtULl1w6br573RMVOUId8iipQuF250zz2P2RtmC3IgBPWGHvo2xBgxJe45IUqfuJc8dOpHVCYLQ1Q6mSXj1g/WwuaUdZr6/1nkMrfXbWjsSnZN/wOeVI633hX9g9x6nddMpq2PqiKiNu0DVUAhDBv0cDfVpDBnA+L0mN1ldgYaTI2njZb5IciQIVUK52KWa8j6ux45LjpLYoMZVjgq5O2eeB+8vSlbHMZ+KS0xcVt58uK+pK0+K2VgsCILQJS5xCUMTreNR/bN0zPaEyRGPTSQJQ1xremJDBhabfMl3xP0WZM5RqOcouayuJpUhgzsxbGvPrxeW32OBhB6JkeRIEKoEl566K+8j+Zwj0CtHNkMGS8+RjXxL/XGVI77DFXUJm+lEIitv471TEFfvO09XIMmNBEHoaql1Elq9D94kk45a65NWjvip+Hm12GRZJKOcRLOPQ1A5ggSVowI4qZqVIfOcSQa7Jqna0Hu3mh+RM2ye8/eyP0vlSBCEoleOuu4+TEcgm0NPaAYQabtrI2R13C61hJUjs+coqgKWV+XI4VZHyVE+MkG6dqmlC4IgCHyvLqmsjta9qI0+v3LUllBW53B0dY2ZMOXItrjEH+cbWLZD6ZoFqRxFzNiLu0ZtCiOEKAm7H5tyTPZ4PBJZnSAIFWWXmvo+zEF7Fre60M5VrWnIYNt1C44JHHRK23Ok3Opieo7iqmNxx4eTo868BsDqQT7nUwiCIBRk9l06WV1ngp6j9IYMzsqRxbkuqu+G3yPfuLNVWjrILKgYbnUhWZ37tTXs0LikJCoxbCuASiMYM5HzKXK7bmkvJwhCtSdH7YnmHEFqQwYKhHFNr4FbXaF6jvS5RlolKVLXbT4XfT8ulyPf/jWP92Na0gqCIJRzbApkdfGVo2259Bx550f4ssjXbTMuuWV1zJABSuRWFzF/j9+79bU19p/t14mfKZjPwHX6W5R6zIQkR4JQJWhJSYENGdZtbY0MUk7bVqwcsYoPYQYHf/coyso7ExwT1fQayPgKs/yZMrqkg+vMZ+KCkKvptzC7cyKrEwShPGbfJYHiTVQy1ZHSkEGrHHlBBpddPSGyxaXw6233kY1N7mPpuEL0w5qVIjNBidy4A1Ydg6Ry7/BzbQVw36O/fa79tLkiyZEgVKMjUKbTutNj0tzWAcdf92+49MF5zmNWbWqGg3/xFHznL7NzCoQ2QwbzQ3poh84WWFjPUZIm0ULJ6niShfedXFaXvEE2+zxYdyeDQXt5JEfeyaVwJAhCJRgykNlCpCEDk95RpSnpfdB5wxt1/He95whf3hnTDxs1oLygbnUxPUdJ+2FrcjQK0tzqDBvxSpjBJ8mRIFQJpjY7SQx6/+MtMH/5JnjkjRXOYz5Ys1XN2pm/fGNubnW+rC5+4aYF37YQZ5IO2iuADI3DkyyMP3yTLEoKkMYuNUrXTk28IqsTBKESMWffpTJkiLDyph6epNUjvrba5N4ucwa+zttn61HlCKJ7jgq4cWeu5Wb1JqnkOzYuRVTC6N/GtBGvhBl8khwJQpVg7sgl0XbT7hmfpWNC59ncnKzplQc/XFBthgzm5/xA9hU+h3nexHaphaocGTI6fe5RIStH9sSwtb1wsjoZAisIQqnRpdbJXkPDr6NiE98Q3NYWH59s8SJq5IJvyKAlR9GqhqiNOz6WoeBW3inmHNUm2Kg0z2PLaQvR30vvQ3qOBEEoUeUoSXKU0QKR9RjW9JpkfpKzchQxPNWsbNjd6phdagLpQiGmkPN7ovtOaoOatnJEwcHccfQrR2LlLQhCBWI6mKaT1UVUjlimlcSUwXbtKFmdOZw8iarBl3xD1MZd/rGJ9zepa9cFRkXm+wi9tob3HMVcJ0JWV4iZgnQrIqsTBKEomAlFlAWqqRlOYpeKbG1JIl3glSOW1KToOYoaAqsSlCgHnQLI0Dj8PHhdHliSNr2q32NWf1fVjAJQj3x03dJzJAhCmcy+K5QhA49bSWR1tnNFjVzw4xJ70Hb7fl9thFsdxqpCz+AzJYBJ+2FrUlSOop1hC9kPK5UjQRCKgBl0kuzQtbAA5DJw4LKGTc1tsec0ZRC2gGCupeY8CbuVN53HbXvNr1+MAJQdAuuugHHMzcFch+1RVS+/yhF0iXRBEARBk1ontfL21r0oQwYe45JUjmwhLtKQwSKrsw4o9/YPcY12mQXxt11fpNhkDiwvRM9RXZSsroCqBplzJAhCUWjPpeeIOfy4ghA/75aW9LpuchGKGrRXE5onAYkcgexNol6pv1CyOuO+c60cJdV2m++pENIFkdUJgtBV8A2zpJUjek2UIYPWc5RgEKzt2uYabquqaMmRTV7m24IHCYp5Kf4+UAJXCLg8D9d2reoVNQQWCjME1o9NebnVhatzpUCSI0GoEvIxZIgKQjwAJTFlMCXitiZUbeeKHZusclTrv6bYdqnmeUydd9JBe8m03cWz8g4ai3M+hSAIQkHGTESNlsAvza0uYeUokVudVVbnNjKgn/i6aXehC7/W3OTi91qoypHWc1Sb25iJ2phbSSSrK4CqodQbd5IcCUKVkI8hQ/Znl6wuOGZzAlmdmdgE8ySCx1wJBh0TbcjAJWi244rYc1QTPcyWYy72sTt0Ditv+jcqiCOQZEeCIJThnCNMOnDm3rRrZqiYQ+telCGDXjlK0HOUwK3OljjwddNqyMCcVF3yaH6vhVqH61lQxVNGmR65HflqEhoFhRPDwK2u8pxU60t6NUEQKsqQgQ/OcwWhtLK6DuM8dF6XHE17PIkhg6brDl/fX7ALJKsz5YCarjtKumBWjmLW/h7eyWjn1Hw/YuUtCEIlos0XcmzabW/rgPc/3qp+3ri9LRgzkdAsaJuxbtrvI4msLqxwwO/4I748cs6RNqDcOIZtPhZM8h1SNSStHIH1Z/uxvBqmj+GgjdP8YlOy+yg0UjkShGqtHCVJjlgi45Iv6IYMSXTd8bI6s+fIf9zRd5M9b9BzFBgyRFWYCqXr1u/b7EEq1Jyj/j0b/A8G1kF7+QyB9SJBteRGv/zlL9V/I+eff77/WHNzM5x77rkwePBg6NOnD5xyyimwatUq7XVLliyB448/Hnr16gVDhw6Fiy66CNrbk833EgQhSeUofqMO41IwBDbCrU4bApugHzaTzjjH1n9kizn6gHJwjGTI/o7PR83HK9QMvqSGDBAj+I6a8RRIvvOJTd7GnfQcCYJQDKI0zslkdZnY3bkksjpXz4wzIbJUjhIHIIiac1SoniMmXVCSPv5cRAAyfo+7nQG97MmRVI7S8corr8Af//hH2GeffbTHL7jgAnjooYfg/vvvhxkzZsDy5cvh5JNP9p/v6OhQiVFrayvMnDkT7rjjDrj99tvhsssu64J3IQjdB232naNypCVH7Sw5ipxzpMvq/vD0u/Afd812xj7rnKNIWV1CVUMCs6BCDye3utXxe08Ym2rjKkcs7ISSowK8p66KTZIcCUKV4LLQjoInRK7jNVldczus3dICD72+HFra7TIG8zxBz5F9V8vWf2SLh/T2dF23zUGnsD1HPCdJY5caNXk9TeXI7zmqrTxHoFKzZcsWOPXUU+Hmm2+GgQMH+o9v3LgRbr31VrjmmmvgyCOPhClTpsBtt92mkqAXX3xRHfPEE0/AggUL4M4774TJkyfDcccdB1deeSVcf/31KmESBKF4hgwtoeQoexwe7lJBmIYMNz77Pjw6byW8//GW5D1HISvv4OeahMYEgeQ7qMqYR9kUFIXvhw1+jqI2ofrBjDtmX7Ivq8vLrU7/XiokORKEKsFc+JMYMvDdOtcOHU+60K3u6iffge/99TV46PUV1uNd1zX10bYSP63Ddre6ILhE9RwVcgp59nq6XaqW2CUctEevTZIcbdimfxAPdN357M7Z76m7gbI5rP5MmzZNe3z27NnQ1tamPT5u3DgYPXo0zJo1S/2O3ydOnAjDhg3zjznmmGNg06ZNMH/+/BK+C0GoPsk3T47wZ03V4NDi8cfXbGmFrZ4pQ0ub/Xib01x4E8tROapNMGZCDYGlx4obl9T1jP6opJtgNQ7poI2mhlq/H9apaijAxp0YMgiCUBS4/C37e5Keo85Uc45QVrdqU4v6ec2WFsd92M/j0nLzn4MAFLE7F9NzVGgrby4ZUHapid3qIF3PUa8e1gBE/0b5WXl3f1ndPffcA3PmzFGyOpOVK1dCjx49YMCAAdrjmAjhc3QMT4zoeXrORUtLi/oiMJkSBCFizERnJwQDGaJ7jmiDrtHyaZabHCxdv83/2aVqSCKr00dOhI+L7HNlhgyheXUFjkvmubiiIm6dr01ROcLYMbB3g4r767e2wk4DehbUSVV6jgRBKCpm4Sdtz5FzzhE7Bt3qPvaSIh7MklzXpt82Hw9kddGzJIKmV/f95lNp4ehGEu6dxdgdyZjrOA0ZCmHl7b2HKBlgJbN06VL4wQ9+AHfddRc0NTWV9NrTp0+H/v37+1+jRo0q6fUFodwxlQC29Z2bA2Fs4YqFJJLvpeuC5ChNbIqU1Vn6ZM33gtUoOq1KUHxZA5S054iPmUhTOUrCQG/jbn1I1VAIK2/9e6mQ5EgQqoRcKkdtKa280a1u9abmyONd13W51dkMDmyyukyCpteiD4FVjkD25/KuHPmyOnvPEUkb8gpA3TQioGxu9erVsN9++0F9fb36QtOF6667Tv2MFSDsG9qwYYP2OnSrGz58uPoZv5vudfQ7HWPjkksuUT1N9IWJmiBUO5g0LFu/TX03Y4Jt3W5hVtyY3OhOqvGxZqUXl9S5HMfbQpO5rOqbX/GqBn4PuqzOrBwVvufIlKon3QSrsUjZkyRH67a2OmKTGDIIglCmmPHAtdt2+wuL4airn4UVG7drAcgtq+O67hbfztu5O+foOXIlRFa3usghsKXtOYqy8i6kIcMALzna5NB15yVdYPM6uiNHHXUUzJs3D+bOnet/7b///sqcgX5uaGiAp556yn/NwoULlXX31KlT1e/4Hc+BSRbx5JNPQr9+/WDChAnOazc2Nqpj+JcgVDt3v7wEDv3VM3DPK0sjEwpX5SitWRCPBWkqR2G3ujgrb+Oc7MKYoLgk38WoHJmxie43TqJWo/0cfz+DenuVo62tsKm5Df44431YvmE7c6srhOQbSor0HAlClVaOXMYID7+xQg3be3nxupCuO410gTfQatfN5GPI4K4c6cmRu3JUiGTCdd+abCJm1828elK3ug3OOUeVF4BKRd++fWHvvffWHuvdu7eaaUSPn3nmmXDhhRfCoEGDVALzve99TyVEBx98sHr+6KOPVknQaaedBldddZXqM7r00kuVyQMmQIIgJOfdVVv87yGzIEvo4AlNc3uHloSkVSm4kiNbvDA3jFz9OH5sCplLBD9zVYN5KV/RUKC4pM5lOKdSohdXnap1bFS6wJ4jZN22NrjvlaUw/Z9vw7L12wsk+Q7fUymQ5EgQqoQkum4KPJTctLYzQwZHzxFveuXVpSQyPE6SIbBJKkc8ObFXjsj6uvDJkRrgl3AKeVTQjUqOcF5Hc1sHXP7QfJg0cgC0ef9G+SRH9NLu2nOUhGuvvRZqa2vV8Fc0UEAnuhtuuMF/vq6uDh5++GE455xzVNKEydUZZ5wBV1xxRZfetyBUIlQJau3oCCVDts0vvtm2tUUf6OreuMvknRyZa7gWm/hxrooQ+533w1IIW7mxGb5z52wYN6xv4d3qjNhEv8cbMgD7uSZ5z9HWVt9Ndd221gJJvrtGVifJkSBUCWYy5Jwn4dmcmnapSSpHnHwMGfTF2dJzlOOgvUI1iUZVjlxJnomZN8Ut/v285Ah57p2P4a8vL4Wn314Nh+w2JO9kb9TAXur7SO97NfDss89qv6NRA84swi8XY8aMgUcffbQEdycI3RvqZ1XmCgn6YXk82drSkSgJclaOOvKQ1blUDX7S446zuMYHku/s4y8uWguvL92gvoo6BJZJ+uJCX42uq0tlyED/TjhXqhCxdo9hfWH+8k2wyw69oZRIciQIVULi5Mhb3LABNtGcI9eMCWfTazpZnU26YLt1qibhOkybb/w4HPyHO1iUzBUqCJm67qQ2qGblKG5jDP8+fZvq1SwpDBYI/uzPksgjAH35gFGw7+iBsPvQPjmfQxAEIXXlqD0TWs9tMaI1qnKUoOfIdS6bqxzHLOS4qipuWZ1ZOfJkdY57KegQWHbz3CwolSFDTYqeo22tsMVLXLe1tvtqk3xkdVedsg/8v8+M969RKiQ5EoQqwQwULmMElGzZKkeu3TZXRSnN7lwS++7sMeCeJeEP2qtluu5O/z197vfPQ88e9QWfRK4ncvquXNQ1wpWj+GsN6NWgEqK3VmzyJXatngwyH2tyDIZ7Ds/KOgRBEIoNrcPNloGsthjBZxNtaY2X1WFS4ppzbk+O7MdGyurSGjLgqAe6P+9xM04WqhdWXc90qyOJWipDhngGeonLuq1tSlpHlSOSfOclq6utKXlipK5b8isKglAyMKBc+uA8+NeCVWFHoI6YylHILrXIsrra5I5A9jlHQeWIXkJHoYMOTkdHNz2/clRX/MpR1A6d6QKUxCmO+o4WeMkRsml7e96VI0EQhGLxi0ffgi/9cZY+yNX74LydWXRHJ0fBa7cZsjqbSsEVl9S1LccncVHN/g7RVt4hc4lObQaemUSZ946be4VCj01BUpTOkKEm9jqDPFnd2i0t/pxD3LgjVUkhE75SIZUjQejGvPrBerjzxSXw+tKNMGZwr0TBgHboQrK6BENgOa2OZCrtnCMtOUrgVpe1LNUDlc2GvFCNrzyYhWR1UW515vyMBNei5AidgAgaCluoHipBEIRCct+rS9V8toUrN8PEkf21BMWWHFlldR3pZHVRc/xsTqpJemHDg18tPUfGeQIZd60WE0jVYG46Fq3niMWmeFkdWH+OUjQgqzdnEyNKjnxn2AocoFd5dywIQmIoiGxtbXfuaHFwweaVo7ZEc45claNw0Es+58glq0s354iO48Ns/XMVoefINGSIltWlc6tDBvQMywsoOcpHVicIglAsUGLF1yq+JpOMm8uvrJUjJr/bYiRH9sqRfdNOncsSm3h81BxSQ7K6GFWDw5CB8gNSDNBhZhWroENgjTiaVFZX60gAXdhkb5j0FsKtrquovDsWBCGnpldzh8qW1ODxtGhjAOEJUZIp5Nq58plzFNv0ajmvxa2O3osteBYqmdDdi8K7dS7MZ5Ls0HHHOoKsU0VWJwhCucE33Hhy5FeOvMSJr8lxlSOsSnBskm8elxrra2NjEw9LDYYagOPcuCNZXcYdl5DAyptUDUbPUSGTIxbjME7R20pTOapNcDu9etRBD+NvjIYMgVtd5W3cSTQVhG4MBQEMTqHKUcwsCdypSzKF3FVRSltp0na5jITDP6bWXX3yh+ixWRK+I1BH6SpHNhlgoSpHJKvjYC+VeR+CIAjlAI8pWuXIIqtr8D5g2za/eEJjVo5sG3Q8zqDLp+tctnPwD/PmnpMWm9jjppTbPC+9Lm7jrrBudUbPUVJDhhp7/I06nvqOCDTaoLgryZEgCOWZHLVhc2S8lTeXLuAwWB5EXMkODVV1XTuplbdNopBGVhdYeYfnHBW358guXeD3a8N8Ko222wZ9sBAEQSgXuGxOqxxZZHW0Jse51Zk9RzZlAJ0DE4SePeriK0fsmrwKn7xy5F3XsQlJcSJcOSpiz5Epq/MNGaCgQ2DjYlO3l9VNnz4dDjjgAOjbty8MHToUTjrpJFi4cKF2THNzM5x77rkwePBg6NOnj5o2vmrVKu2YJUuWwPHHHw+9evVS57nooougvb09NKBvv/32g8bGRthtt93g9ttvz+d9CkK3B+f4/Obxhb7MigcN3MExA057TADCRIlXXFxzi+g8WFrP1cqbnHyC3x0SuyhDBu8xPMYMQKYk0JS/FSMA8ftNlhzlVjmySUEEQRDKAW7VHSWrw+WPEoO4OUchWV1E5QjX414N9anc6rSKS8KeI4oDZLTgn9e7lN/vY1SOwnOOCreOm7EosSED2KtjUUTZbVeiWVCqO54xY4ZKfF588UV48sknoa2tDY4++mjYunWrf8wFF1wADz30ENx///3q+OXLl8PJJ5/sP9/R0aESo9bWVpg5cybccccdKvG57LLL/GMWL16sjjniiCNg7ty5cP7558O3v/1tePzxxwv1vgWh23HTs+/DH555Dx547SP/MW6uEDWczhbITEMG5xBYb+eLpmTnYuUd2fQKSStHwTGmXWpolkQhpQt1dumCupdUsjrILzmqQOmCIAjVWTkyZXW4btN6aYsRUbI6a+WoI1w56ufJ6+w9R4HlNk+IzETCZVZAP5u3EpbVZR/vhOL3HJmxif6+8YYMkGrTjs86st5HbTe38n7ssce03zGpwcrP7Nmz4bDDDoONGzfCrbfeCnfffTcceeSR6pjbbrsNxo8frxKqgw8+GJ544glYsGAB/Otf/4Jhw4bB5MmT4corr4Qf/vCH8NOf/hR69OgBN910E4wdOxauvvpqdQ58/fPPPw/XXnstHHPMMYV8/4LQbdjgBZ5VmwI7TUoKcN037UtjK0eGIUObcwp5xi+rf7RhOwzt26gsPdNVjowA5Ow5cgdP7lbnv8bXdXcWzxEoNOcIcjJkSOZW19CtducEQeje8J6iTRZZHS3l3OnTHpsirLwtsmmKS6py5CVHIwb0hE0rNztkdew+Ija4XGYFrthkGjLQyu+ac1TQIbCGxJvuN65yBI7qWBRmzxGnEs2C8rpjTIaQQYMGqe+YJGE1adq0af4x48aNg9GjR8OsWbPU7/h94sSJKjEiMOHZtGkTzJ8/3z+Gn4OOoXMIguDeoaMJ1S4pgm9zHWfIgENg+ZyjGFndxJ2y8yv233lgpAzP1roUNYXc5lZny9Pao3qOjGBYSAmaKcHQpQzu14XmZ0BubnWVrOsWBKFaK0fhDSvXIFVEn7kX3z8bDPuuhQPHDlJuap/YdUisrA4rJa6Ze+bvXNVAL/l4czMsWL7JumnHjytFzxE/Fx9Am8bKuzbPyhGvWFUSOUfTTCaj5G6HHHII7L333uqxlStXqsrPgAEDtGMxEcLn6BieGNHz9FzUMZhAbd8eDD/ktLS0qOf5lyBUE6TdXsd6jnhA2d6a3W0jy01bQOGBDH/We46ih7oes9dwmPmjI+GHx44LXZtjk8SFpQvsZ7ZKRSV2vPE1zi6VW5zmi9kfFSXJKGTP0bB+jdpzlegIJAhClfYcmb02rLJhldU5NtuQNospEFWTMB6cP20PmPfTo2G/MQOcQ2B9Qx81RDx43Pxcr/eY8uOyv/z4/+bDZ677N3y4dmto044f555zVMieo1pr8hlXOap1vMcoBjJDhuH9mipe0ZDzXWPv0Ztvvgn33HMPlANoFtG/f3//a9SoUV19S4JQUqgytI5VjnhSQM9TidvuCMTc6kJW3vbgREkTLrwoW2isr4tMjmznMXeyXDt3tKhHyepqE/UcFbBypNm+RksyopKhJEGIOwLtMayv9pz0HAmCUG6g62mUIYOt6p6JcVI1iZpzRNUTjEtRsYlvrkUN8uahI2pY7LurtoTOy1/T6VA1FNStzthYpDgbV8mpcfT8JjFk6NlQp23cVaqiIae7Pu+88+Dhhx+GZ555BkaOHOk/Pnz4cGW0sGHDBu14dKvD5+gY072Ofo87pl+/ftCzZ0/rPV1yySVK5kdfS5cuzeWtCUK3ldVRZYkG4sVZeWMyxQs0be3RVt6UJNCHdNwxizJO4IR13famV+5Wh0Pm9POyyhF7HINQUe1SjYGBlJjht7hqkBaEElSO+jTWqy88dNxwMzmqzCAkCEL3BcdIEOSkimty2KUtWDttbqQtUZUjy3O854gg1YStchRsrrln7kXGJmP97tVYFzovP45CoykRLKSqQYtN7O+bzpABEjG4dzYhGt6/SbNOr1RFQ6poiv9BY2L0wAMPwNNPP61MEzhTpkyBhoYGeOqpp/zH0OobrbunTp2qfsfv8+bNg9WrV/vHoPMdJj4TJkzwj+HnoGPoHDbQ8hvPwb8EoRobXzVZHa8cec/TTo41ALFdvs3NwS6fS7qA+FOwvYWYT8qOs0xN4tzGn6GgdfdLS2DvnzwO/1qwKnReTHz4+fBhs1+qoIYMRoD0d+cSRJW08gUMxjd+fT+4/mv7wejBvbXnKlW+IAhCdcjqNre0q00sm+FCbQq3OhPb+czKEY99re0danPtp/+YDy8vXqe71RmDvCMl3xFJlG84YcjqakrpVheawZf9OT5fqQl+Sng72Nf15f1HwX8dvSf06lFfFJVGKalNK6W78847lRsdzjrC3iD8oj4glLOdeeaZcOGFF6qqEho0fPOb31RJDTrVIWj9jUnQaaedBq+//rqy57700kvVuTHBQb773e/CokWL4OKLL4a3334bbrjhBrjvvvuUTbggCNHJEUoXKBngO2QULPyeo47oylHI3c7RcxQ0vlLlKDo5MjXY2Z8T6rrZL3iaa558J3RevkOWPQ4rR4YhQ0F35/R7pfcStztHx6e1TP3k7jvAZybuCH28nUlCZHWCIJQbvI8V84/Nze3WSg+um1GGDHzjzsRmFsQNGQiKfRiXnnn7Y7h95gfw+6ffDc0jipTVaZUj/rh+fVIr+PP3jDlHtNdoq6AVCrP/NamsrtaRAEaBf9tffWEfOH6fHbXKUY8KjUupkqMbb7xRSdYOP/xw2HHHHf2ve++91z8G7bY/+9nPquGvaO+NErm///3v/vN1dXVKkoffMWn6+te/DqeffjpcccUV/jFYkXrkkUdUtWjSpEnK0vuWW24RG29BiIBkc7gWk7bbttvmJ0dpA5CzcuTJ6rwVlWuMUU/9s4cXwDVPBMOiaSeNf5g3d+dccgVzUd91aB97Qy1b2fDh1iJaeZs9R0EQjH+tNmwv5S3x3TlEhsAKglDOyRGCsckWl7DC4MvqLKGmEJUjkpTjuTZ5ygiyBefziFwJkHo+xpDBvF/Trc5lFkSPF69yFE7QXNREvP8k9GrgsrrKjEup5hyZk39tNDU1wfXXX6++XIwZMwYeffTRyPNgAvbaa6+luT1BqFpwAeaVHjRlGNynMTI5sja9RgQgl1tdyI2ntkYlPng8zju65fnF6vHzjtxdXZuCBVaYSHIRNYXcZshADOsbNH76O3S1uhQP5Qth6ULhFmxzKGDSKeTZ4+3nSQL2HnEamJxREAShHGg2YgomR009wmsVLsk5y+qsc47CCgW/ctSe8ZMiimt8HlFUzHGZFSxZt007jmKOachgrvN0/R36ZOcDFtatTpf90XspRuWIQ3OlqqbnSBCEytidI8c6m3yBKju23TbzPJy4OUdcTkc/c3MIM1jQLp5tsea/awmEcRydEzduaO/GDG74ODkC0aJdyAWb785xaUgSWZ0eaHMPQOZ9CIIgVFLlSMnZjPl0+Vh5+0ZB1p6jjO/eGgyjZYYMEbI6nizx9fu91VsclaPs79yoh1+PYtinJwyDvo31cODY7JzAogwoTxibah2mE0lpYrGpUhUNqSpHgiCU/xRyZL1nymALKNGyunTSBfW4dw1zhw6Djz70L+NMpqIG7em7ePq1SS7Hdxq5PMPsOcKm0Znvr4W9R2QH1hYlACXcnaPjbT/nVDmqUPmCIAjVE5swJthUCErO5i1hcU6qiSpHbMSErefIT4682KDJ6oyKi3mfSdZs87y+rA7sYyZOnLwTXHni3ok21XKV1VGISKJqIHK5m14NQWxqqK/MTTuJpoLQjfqNiHVb3T1H/pyjjnTJkUvW4Mvk2A4R7dDZhv5lrMlRlMV18LMZM+mcPHFTsjrjNZRE7bZDH5jz40/DL0+ZCIWCV6H4dPW0bnWpe45YclSpU8gFQejemElNZOWoNrfKkU3VEPQchQ0ZMDnb0qLHSC5/40tppKyO/fyzk/aGvk31MHpQrxhZnTHnyDsOpeiFTIz4Nc1eqnhZXQ37GfKT1VVo5agy71oQhEjpgl85sgShxqjKUZSszlE5aqOdMZYkUOKzwTL0j67LLb+jHIH4z2+t2KRf2whAdC4etDAI+aYRdbXenKDCBSFt6Cub8p5IVsd/TnlLvTVdtyzlgiBUhqzO7lbH5hwZsQbXb1s1yX8+k6zniEu5N25v1+ISnYLL++z9sPbY9PWDx8AbPzka9t95oHXjjs5J56OQRfMDi1H5d6ka4g0ZgP2cPlZyt7pKdVGViCoI3QCSCBBrt7Q6K0FRhgx8JkXSnqOgchQOQrbKkW8pHiGrc/UcHbzLYO0485x0Ll1WFyRRxbAVNa2808w5yseQgbvVVeoUckEQqiM5omVSVY4cyZHLkMFVNfIHjltUEH7liK35fEOOBtKaMQSXYV06l3xAKiYStBb7G3chWZ2956jYyRGvzMVdqraAlaNKlXtLz5EgdOOeo7SGDFFW3jadOFZlTE21uoYlOfLnPlAyFVE5ciUNJ04eAQN6NcA7q7bArx57mwUg+w4k3SPJ6oqxUHPZQBpHoLgJ63Hg3xj/LfGDQ6U6AgmC0L2hDbchnhubU1bH1k5TVueSdDc11EFbR7vVkMHqVsfWf1NdwZOYKFldnFkBd8Qze5n4azqNxK8YFRbec4SXDZKj5JUjgHzd6iozOarMuxYEITI5Ire6KEOGTGpDBncAMpMESkJshgxB5YjtakVKF0BbaI8aPwyG92+0SvVMaVv2fbLduSLYXXNJtSZdSHApbRcyh2v39gbBVqquWxCE7k2zt+E2rF+T+r7JIavjbmrm05Ro4NP8g3tPb56OvXIUdqvjlZ31Xl+uH5fYsFazV8e8z+Dn8Pul2OebBfkW4fprSlE5MmcE0q9xG3G12uZk+uv2ZKoGriipJCSiCkI3oLk1ec+R71aX2srb7Qjkki9gIDQTLwoKXOIQLaurcQcgX9cdDNLDYFZjVI6KGYB4YoKnp1+LbcjApXWVOoVcEITuDcWUYf2yG1pJKkdmPyzFjsb6Oq36QxWKqI07c+ON4g7J6vA4rBr5PUeG8iBq447POTLPb6tIqddQdSyjx1AeDwsFj8kq6UuoaqjJQ9HQXWR1lXnXgiBYK0folsN7jqLc6uyyOreBg60KxYMSX3BJIrBhWzIr73AAsv9MhHXd3nksyUZpe45qoG9jg/q5t2G1bYPuEb/n0vhKdt6VKl0QBKE6ZHVDvcqR05CBu9UZsYnikpISsyQCZXUuybfNrY7OgWxlG4oY2+iaZs9qWFZn/5mguGarSPHX4KYdXtMWDwsFHyiLp99xQE/18479s9+LYRTEK3pIpUq+pedIELqRIcNOA3rC2ys3J6ocZRImR7gLhI9HNb2ai3uP+rpYQwYtOQrZpcZUjoyEzQ9ARqKCj6ueI88RqBhJhJkc7b1TP/jxZyfA5FHxs5ToveUaPnp5srpKdQQSBKFKKkd9g+TIFmfwc3wgq7P3HGHswvV8s1GhsKkgbHOO1DksMQDvh/cGuQyB6HnXc3wz0WXIQEkSPsp7pYqxhuubhTXw1QNGwYQd+8HEnfoXbf5e2K2uMjfuJDkShG4UgEZ4yREmS/iYbUetkeYcWZxRyZAB10NSNqB0a/22Nqt0gZ+fxyDbnCMzWGiyOmP91KxUbQGIdue8pMcPQMbr8N3gU3TvxbdLzQahMw8dm+i1NXkEIKS3J6ur1AAkCEL3hhIhktWhnM0Wl7KyOrD2w1JcwrhC84G4rNhWiWq39By55Gv4et4bFCWri7O5piTHZcigDye3by4Wy60ONwenjMlajUdRo5WOIE9ZXWVu3ElEFYRuNAR2hz6N/mKEpgxRhgzUsGqTQPRlkjBa6KKlC3qfTw9vKvamZoshA/UcRcrqoneuQpUjdh+mHrwTeM9RcR2B0g5iTTp3Is6QQZIjQRDKOjb1bfTlbPaeo9rYylFjg11WZ+2Hjek5Ms9PSVfIrS5tbPINGSje6XGCXqPk3uzvUJx+2NwqQLX59hw1BJ8fKlXyXZl3LQiCtecIy9kDe/VQP6/a1Gw9NsqQgXbo+vXM9s0gvbxEyTbniJIOU1dMiQ/fAGwJyercC3Dc/J+wIUN4d07rOfIqTMWYBxRnHhGF/9Icc7be3s5ppeq6BUGoDre6wX0a/fV/S0uwaUbgEuYyZKBEA9dvntyQfMumaujwshJXbNLOr2R1wRpuSqXTOIyGrbwzxhDY7HH4Fil+8hlPhUR33cvtHDU5vEaT1YlbnSAIXZ0cYZWnv5fYrPFMGUwoONjm6rV4laN+TSw5oqbXTPqmV05ozlFE5Uj7PcKQIZhuHt4l9HfoMjjnqFSyunSBgJKpXOMHmT40iJW3IAhlLPke5G3amUY9BE8QQoYMXlzCfh4tOWqg/p7klSOsPkXL6gJLcdvrtapKbQJDBi/O+nOOSNGg5u8VT9Fg3nuqylFttKw9Dvw3oqpVpaoaKvOuBUGwShfQJYYqPWTKYEJmCXZZXfY8lGBpdqlRum5jcbctiCRdoLgXZeUdV9Yn2Z45O8k2g6KzyHOOeJ9T2jjgu9XlWDryDRm8v4cgCEK5gOs9SbWxmkAuZtjDmmrOUYfLyrveqYJwbtw5DBn0IbDu5CDOytt0d/U37oyNMN5zVKzNrVwl37UxfVVpqkciqxMEoSxkdb29RYnmODhldVZDBq9y1LM+tMhh7DCDEO3OJW56Za+PTo7sP/uvrfOqWYZUj6/DwSTy4vYcYUCne0wbSIKhfLlduw/J6qRyJAhCmcFd6Zoaav0eyY3bW1PNOeJudTZZnd2QIUXPEVp5M8dTHiYiZXU1EZUjT8ptGjIEcam4m3b8mq57dVHDkr4ccyN/U1UMGQRB6PLKETao0qJkky7wRMasHOEuHwUzXjnqzaZdm0GIGmGTyeoC6YI6RpPV6cealtwmVCkJGzLUOuYcFW+WBA/ASQa/FtKQgaqElSpdEASh+0JyuCA2eaqGrZbKUZSsjtzqVHIU9LNQJco2s4/im7lxR5WdcM8RqQ8gWlYXE5sorrUYsYmWaD8uodzbi7fFSiByN2SAnF7HoX/rSo1NlXnXgiA4e478AGRJjnCxrHM5ArHER+s58nb7bEHIuTvnlC7Yj4mcQh7Rc4RJDyZ1wZyj8Dmy8oXi9Rzx+09bwPHfWo6xce8R/dTfZ8KIfrmdQBAEochmDLg+4trrb9yxEQ+E6vWJqRypniNNVhcl+U5eOcL4wOVvulTaNAuKjk1UBSJVQ1hWRz1HULK4xK+fiBrrj6mgxLVSzYJkzpEgdAOoVwgXJJIu2GR1+u6ceY7gAVvPkS0I+btzCRyBzMpRQ2JZna1yVGudbm6bj4TJUzFldUHFKpN6ly3fytFBuwyGuT8+WpNBCoIglFNcavLWazKQ2ejFJowtNMA8u3EHjspRIKurrekMWXnHjZlI41aXlUnX5B6b6hz9sL6Vd/a4TpbAFcNFNS9DhprcTYZMyWOlmgVV5l0LgqBBAaaJVY5ssjoMFLTYmfanfAAsBTF1TiZjMIMQ/Z6k50gFIMfQu8jKkeX98mCC92AbtOdru5msrlhBiC6b3q1Of30u9O/VkHPTrCAIubGttd2XMwt2aMONkhjaaCNVA48zKilxqBr85Mi08vZldVGVo9pkscnhVmeu6XwDzrbqmoYM/LzZ1zBFgy+rK0FylOISNfxn6TkSBKHiDRmwcuQHIEvTK07JpgBkbLZxu1QKZhRMaIEzg5DLEci22Id7jtwl/9ieI3Z+Hth0jTWEhu0VKwiRI0/aWRWU1EhyIwiVA1bQP33Nc3Ds756zOqUJelyieNLb27ijx/uw5IjL2Zyyuga7rM7qVueac+QwZOBDYHmYCPXDarI6d2zyZXWGvC/ohWVW3kVyG+VxOdfKUU2OsWlQ76x1e18m0a8kRIshCBXMxu1tKhlqtlh543MmdXXxTa8YyNBZSJ9ZUAttHR2+A0/sEFjHnCMexLjFJ0+GQtIFSz5DMzHwfNwFz7ao60GoyD1HNblWnIpwU4IgFAWsfHy0Ybv6ed3WVtihb3bAqRCwelOzL6uj2UK8f9VMjqIMGYIhsHVQAxmLW13yOUfkdOoyZMCwESUr0weURwyB9e7ZvA+KdVzRULzKEf85eZCp4T1HOcamHxy1O+w5vC8cu/dwqEQkORKECmXVpmb41K+fgYN3GawZMpiVI67r5pIB01yhmVWOcJ4EgQu3Sn7acBCsq3KU0JCB787xpteIOUeunSu8xvZMhxbYdI01WAwZiusKlFpW5wkYpHIkCJUlqSPWbGmR5Mjg/+Z+BD+4Zy4cutsQTZrdmzmfqt9ZsoQhw2XIQKoGTDz4UunL6iyGDE63OssQWExkeAzh63i0WZC7ctTqqhx5x5XGkCHs3pqEmog5T0nZZYc+8B+H7waViiRHQtmDi4ytElHtvLFso0poXly0Vi20pl0qJTt9m+qD5Kg2kNW5ml4xMeJ2p0rn7S3eZN1Ntt/+nCNjcXc5AvFdNE06FzWF3LE4Y6KDxTE+o8LWgIpBj95qsZpDczVWCIbACoJQKWxt6dCSI0HnxUXr1PeZ769R35uclaMGXVbnHALrVaDM5IgqRyyWPfbmSnW99pSGDJpbXVRs0hxRw++dzm/2HJkxgm/aFasXVhsCW2Ir70pHPnEKZc3lD82HyVc8AUvWbuvqWyk7Plq/zU+CKLHBYMHd5UK6brYrFtqd82R1qnJkyuoMB57/98A82O/KJ+HDtVv98yZpeuWucvr0bnAP2nOkDjTvIiuro9eFm2VpB6+Ysjr6+6TNvfJ1qxMEoesrR4IOxQXKWcyeIwI37niVwymr40NgWbAwK0coJT/37jlwzp1z/NfUJdy4o0vyod7q90hVQ/i90/lJMkexyZRe47PFnnMU17vroibGdKIakORIKGtmvb9WVT3mLFnf1bdSdizf2Bx6jPccEbwhknp1rI5AzFkoJKvzPvXTbtxLi9epf5d5H22y7s45DRkclaMoWZ2rckSGDlxWx++DFng+pb1YQSgIfLlVjqTnSBAqh63MpW7N5rDxTbXzobGZSUlM9MYdJJtzxN3qvPPh8o8J1cqNzSoWoMx8c3N7YYbAhnqOksnq8HxKtWBKvjW5t115USg0g6IUQaZW6zmqzuAksjqhrNnq7dDJ7lyYj9ZnG4I53K3OvjsXkRzxyhELIJhQ+G513jbYpu3Zf5dNnulDWlkd3oI2kyhiCrmz58jfoWOBzWJdSu+rmLI6c8BfUuj4ag1AglCJbGuRypELNGFYvlGPTX7lyNi4M6284+YcmYkNScgRjC3832JzS1usqgGXXczDMDmipMbshzVDhj5LL7xu8/Nzh1ZTJcB7joolqxvQqwEG9+6hvqehhtWLqjU0SXIkVIS2++PNEoBMlnluSQQGDgwwPGAgvXskTY4Cu1Ru5Y1SNEp+aKdrU3Ob9j2tIQOejx+SdtCeui/vBHhec5YEfx3tOqoZT0Uq0YwY0BPeXb0FduzflFvPUZUGIEGo9MrRx5IcaSxdt83vgSV8t7pQ5YgZMqBZUEzlCBMP/gx3VcUxEzw5og28qNiEw85xHmBLR4YNaTUMGSJik23Z5uoEbUC5d1l+7mLL6lAB8vR/HZ76/DXScyTJkVDebPF26CQAxVeOSGLAHYDocQwQuLOmzTkKudXRNHPdkKFRyeqCniM8jhZ1sgsPD4ENL6im5XZSRyCnrI5pu0PSBRa4KOkrliMQct1X9oWl67fB7sP6pnodVYyqNQAJQuX3HImsjvOBpT/Y1XNk9sO6Nu58K29MjjqDJIfP8cE4wDdRaeMuqnI0wEuOcEQF3UpI8m28viaucuSYweerBNixpGooZmzCBDAtNTEJYDUgPUdC2YIfpulDeLVXjtCR7gs3zoT5yzeq3zFBMeUcga5bD0B8qni0IUNQOeKGDFg5osUbd+co6Gi7c3XpZkng6WzOckSUW5Bt2J5VVkc9R14vVTEndffv1QB779Q/9et8GXq1RiBBqHS3um4QmzDWfv2Wl+Cqx95O/drtrR2wnKkYPliTNWPgkJW36VanyeqYSxwpDMIDyuv8WIYxh2/KoeSbJ6pBz5Fb8j2gVw/fDY822NR9RPQV6f044b8HHk+xxuyzpfOHKkdl5sZbGyF5rxbK619EEBhbW7rf7tylD86Do6+doQJKGv4+Zxm8+uF6+Oe8ler3FTYzBkflCIMBVYKSGDJkrbx1Q4Zgse/0EyJdVlebaggsn7eUva/0O1fcMpUSPd2QwXtfRZ4lkQ90t1I5EoTKoRzd6tAhjqr/aVm4cjM8/94auPPFD1O/9tt/fgU+edUz/lDcDzynul136B2Sv/WOdKtjG3dmbGK9ORRbcD3nznJmz5Ft9h2dg6BeHLPCw18SPecoJjZZzIJqau3vq5yoTfAeuzvl9S8iCBZJXTkFoHx5+I0V8M6qLbBw1eZUr8Mp7MhmLxkhSd3YIb39RZcqR7hLxxc0ZX9Ku205GjLUszlHJKUz+3k4vErT19sd5M2pdXUFGAJrM2SI6Dkqx+TIJrUQBKFyKkdrt7aGDARKzVsrNsHhv3kWzrt7Tk6vpzl42EuFM+zSMH/5JrX+Lv54q5YcHTV+mMWQwV050jfu9Gu0eEkfKhookaAY48cmIzki6mNkdWFpdrRbnT7nyKFqiDAL0mR1JVA15EKN9nN53VupKL9PC4JgC0BbWkIf5iu5GrbFK/knBQMwlwp8tCGr6x49qBeMGtRLS45wEaafg8pR8JxrlkSzZuXNeo6UrK7GKqsjonTd/bwAZM45ipLO6cYK9r8J3ZMyZDCaXrXKEem6LX1QXY0YMghCZVeOcO1Zv61rlQ3PLFytenHeXplu082MS/heKA4kAaVs2LODUFz4YE02Nh2+xw7+2u0PgY3rOWIDUrX78/7e+PpGL7bRZleDdxG8F5v8HjfiOFwV4cvqmFkQj5HZ3/Xz2WbpmVACx02IbI6mpeiHzYUazZABqpLy+hcRBEflCD/7dnUAyhdcgMntbYtnM5qU9V5ytImSI69ytNPAnrDzYC85Yk5APAjhwqtVjryVj2y1CZJkYDKEu3G048bnHGVldeF7D1l5G45A6v1zK28mobDPkojfneOVIz8ARfYcld9yJ4YMglDZbnXlIPt+ZfE6LU6khZIPssB+5u3VMO2aGfAamy+IFaU/zngfZr6/xn9sHYvJqGrAjSiy8d5jeF8YObBXckMGJrU2N0K3eRuleHxQOaLeoyA2pa0cUWzKbrBBalldbD8sk5JzNzyiXFUNNSKrk+RIqIyeo+5gysDfD1WAkkoY1pqyug3ZnqOdBvSEnYdktd3cfpvLF7hMTjWb1tkNGShAktRh6q6DYczgXjC8f5PWYEoJWtoAxCtHXN6n7sviCBQ3IJUCij7ALyzHo925ctN1IzVVHoAEodLnHHW17BvXVOxHpaQtl74jHptQsfHIvBXw3uot8Pj8Vf7j8z7aCNP/+TZcdP8b/mNrDQMEsvHGJAbn60zYsZ96bkifxtAGHtLLNefIiE20UYpW4LsO7a2UEXvvlD03j038flzJDVdFDKSeI77BZjiphsdMJKgccVldp74ByE9HqgZbj25XU+vH3+oMTmLlLVRMclTpfUd8dw4X+2Xrt8EXbpwFXz94NJx35O7+c7PeX6t6jI7fZ0d/gaVkypTVYXJEs3XwZ1vliDexosOPL10wdudIxkizKP78rQNVxQ6DC1WO2l3JUV18cmQOxONBywxgdAwen6TniBZwbSJ4TXnvztkGAwqCUFlreVRs+suLH8KgXj38tbwYvLN6sx8XEFRY7Ng/iAVpJewo+aZNOJSzm+8RjRewQjWwdw+/FxbBuLDUUzSg1BvX7ctOmABHjR8K07z+I9X/WlcbWHPXBb9jCLEZMmDMoQ0uTLrwuq9cOg16eZuBFJswMTLVEPz5KLc60/E0yklVd6tzxCa2cWeOmdCTo/LsOfLfG8ZfqE7K79OCIFhkdeVQOcIqz38/MA8uvHdu6qZVWwB69YP1sHJTMzzqOdAR2FR77t1zYLFnicqlEjT1m5yBUFb3uUkj4PZvHgD/efQe/nG92Q4dBSRfMuD9v94MJJSMktQBF0da0IMG005rz1HYkMGWHDG3OiMAmbI6/licI5BNusBfR7tzZgJXDtC/hSvICoVj+vTpcMABB0Dfvn1h6NChcNJJJ8HChQu1Y5qbm+Hcc8+FwYMHQ58+feCUU06BVauC3XNkyZIlcPzxx0OvXr3UeS666CJob0/XQyhUNmRgQOusLTZhFeXHD74JF943V33ALxavfBBI3xCesOSkamhp8x1JedLHEzA0gDCfR7n1Bk9mN6RPD3849hf3H6UlJNzOm5sFuZxUuYSRVA0Yo2itp9es8OR8JubGm29cxIadR1WOouccWS/p97cqJ9UKlNXpYyaqMzaV37+IIJRp5ej9j7fAXS8tgb+/9pHVSjtt5YiSDD7gVkkDvOD20qK1Fl13u9qJWuldH4MPaq4P33Mo9G1qsMoVlCGDv8sWVIHM6pEpq+P4Ta9oyMCsvF09R3gdWlNxBlB4zpHuVmfTbgeyumhdt9KLG02v/HXl2vTKnYCqM/yUlhkzZqjE58UXX4Qnn3wS2tra4Oijj4atW4O5LBdccAE89NBDcP/996vjly9fDieffLL/fEdHh0qMWltbYebMmXDHHXfA7bffDpdddlkXvSuhK2PT6MG9nT1HlEDg+oObYMXi1Q+y/UbE+q3p+lnNBAQ38WgTzjY3CFngvTeeiOHzZM4QNXi0t0PVUFdb66/fWnLk/a2xumKTn1HVhWJi3MbdyIE94asHjoIfHLWHP6xcM2SoiXGrS1k5MmMTf0WwcVeGsammulUN5fcvIghl2vT6xIJgB5mCQO67c+2w0TsHd+LjAehlL+itMwIUWmmTscMOnpbbRKscedIFW1LCq0dU2TLtVnnVJWnlCBdWuiY3ZODJEVc72Io6geQM4g0ZLDMtaHFvLeeeI0oAy+/Wuh2PPfYYfOMb34C99toLJk2apJIarALNnj1bPb9x40a49dZb4ZprroEjjzwSpkyZArfddptKgjChQp544glYsGAB3HnnnTB58mQ47rjj4Morr4Trr79eJUxCdVWOyAzHtnH37uot/s9L1mVl0HHgWvb60g2pnFlRgcB7adZubckrNqFZEG2AcVmdLTnSe46wctSmzQ+yQbJtU9XALbR5Pyzdm23TjicWrgTUVvmZfvI+cM7hu/rDyk3LbX3jzn2+uH5YPTaB062uRxmqGmroe/ndWkmQkCyUvayO/s+ZRFaHi/mnfv0M/PKf6Sd9x/Evnhxtb81bVkfzgnDtpB047gT3CiVHrHKECzi5ASnnHkcjp+ZWpypHQXLEF/uMLQgZjkIIn3Nkc6uz9QyZyREPBqaVt+31gUY7unKUrUhlH6uN7Dkqv1W+2nfnuhJMhpBBgwap75gkYTVp2rRp/jHjxo2D0aNHw6xZs9Tv+H3ixIkwbFgww+WYY46BTZs2wfz580v+HoQwKGH74k0zlTS5+JUjd3L0DptlhxK75975GD4x/SnlBOcC3eBOvP4FuO/VpYnuA+MGSazRQCdXxzpN1cB6jnBDkiTk9BiyYLmXHBmVI4ppA3pmZXU2SNWA6zOu8RTDVB+qpR+WNkl7W+IS35hzVo4i1n26No8h2WG0kEhW55oBxM9LG5BYGcu+HipEVlfjfYeqpPz+RYSK4b5XlsI5d86G7UaFp9ABaITXXJpEVodTvj9cuw3+NmdZQe8FE7PXlm7wf6eqT+5udW1aBYbeG39s6brtasE3NeQYaJGBvRPuztXVQiOrHHFZXUdOsrrwe7ct7hQgeHK03XNSqi2ArE53BNKnkKvXgzHnqCwDUPZ7lcafLiOTycD5558PhxxyCOy9997qsZUrV0KPHj1gwIAB2rGYCOFzdAxPjOh5es5GS0uLSp74l1A8Fq3ZqvpwHnljhd8DU0gwWaDK0ZhBvZ0bdzjsm1eOHpz7ESzf2KwGgTvv3Rukuujj4LVRLPcSI3SDQ7kYsq4AqgYy3cFqP/3MK0foZIfrqlZZagl6jqJkdX08ZQKtx9aeI8umHbf95tB5SOo+qHePSFUDh65tziPSN9miZHWO89bZxkzQayqj56hGeo4EITeue/pd+OebK+Hf735c1MrRzkN6RVaO/j5nGVx0/+tqsV7oDcHDY/lOFwePw8oSVWaS8PTbq5RFKbHBkiCkGRyI74122eh+EbOfB+/RTI4w+UPQBclFL9PK268c1WqVI7uszl054sEytnLkBR4aAouQzSwGrKgAlEhW5+0IZnf9skGmNqrnqCztUqOrY0JxwN6jN998E+65556SGEH079/f/xo1alTRr1nNoAsogUNRcW39+SMLnJWFtPB5bXsM6+MnP9ykB6tX72uyuu3w9opsbFq0xp340OYYjw1JkqMRA5r8eLAuB1kdJXvI6k36wHVKgHg8xfePCRKvHGHsorhIfaZRqgaKD1zyHcw5sth4W+TevDJEsjocjM6hio0NUhNwQwZcim29q7bf4/phW7lZkMXIoZz7YWtjDJG6O+X3LyJUBLgjQgvzewl3udJCO0Zj/KbX8KKPAenKhxfA/bOXwVNvrdZ262gXzuS5d9bATTPeh6seSy69+9dbq7WFIpeeoy1MVsclCDw5MhM6a3LkV47cyVFv3vTKdd01urUpyRfw7xhUjtw9Ry5ZnW13jmxSh/Vr9IMBJUdm75PVrc5ifWqVLii9uP4aW3JUlj1H3vdqlS50Beeddx48/PDD8Mwzz8DIkSP9x4cPH676hjZsCCrECLrV4XN0jOleR7/TMSaXXHKJkvDR19KlySRTQm4s8+ykEdws+8PT78LN/16sNvMKAQ0kRcZ5c3y4GQGt0WRXjSxes0UlE9mf7XEJoY0nm+mNDUoIcJwDxYNcDBm4M6zp+ka9vrxyRNI63ZCB9RxFGjLUaetxrKwupnJEsYfuxUyOoipH1KfVFtUPGzEENjY2GSZE5jn8fljPGKIse46g/O6tFJTfpwWhIsDEiNYvWvQLDVUyqOkVd6lMS9T3P94K670Fee7SDZrO27VDRzthtoFxUU51yPjh/XLuOTIrRzwAkmMd7RzSjtbLi9e5ZXVRlSOj6ZXc6lTliK11JF9AuRttfNqCEAWy7JyjZMnRr7+wD1zzpUmw57C+frDY3hpUeKKGwGaPSbY7hyYRgXQhHLgoAEUFya6CKkZSOSo+uAGAidEDDzwATz/9NIwdO1Z7Hg0YGhoa4KmnnvIfQ6tvNG2YOnWq+h2/z5s3D1avDvpG0PmuX79+MGHCBOt1Gxsb1fP8SyhRcrRqsz8g9Y1letKbK7SJhB+sca3EzR9KiHCuEfYVUc8QrcPzl2/ykyVMIFx227TxlLxyRMlRT19OlouVN0/46JwEbUpScjS8X5P/nkyrb5LV0cZYVM8RxYShfRt9aSAlJZqsLrbnSP8Yi4PL41QNBBkycLe6bM+Re+OO/xofm3S5nnmOcpZ81/jxF6qS8vsXESoC7IchuHygkNBu1qiBvdSChWsMt71GZn8YSONmvr9GcwVyVY7ow30aaRxVdkhGkUvPEd+di5PVHTg22ySOyR4P9lxWF5UccWmc7laX/SBOCx7tanHzC5oDYQtAGADJKQ/nRPjPWxb3vXfqDyfvN1JdjxZ/6jniEgq6r7SJQ7A712GVLoQCUBnK6qo9AJVaSocuc3fffbeadYQ9Qvi1fXv2/18oeTvzzDPhwgsvVFUlNGj45je/qRKigw8+WB2D1t+YBJ122mnw+uuvw+OPPw6XXnqpOjcmQUJ5yepeW7JBSeuoikRrQT6Y8mNSNny4divc/+pS1Vf0xxmL1GOH7jZEfTfH4mElyQYlILYNKBtU5VGyujySo6jKkS+r8475hGf8MPvD9Vo1CaV2VMmKcqujyhHFhCtP2htuOX1/OGjsoMjKUZysjthtaB/9+YjF1Z9HxIfAhjbuoCCVI30GnyH5LsPkqNYyl6maSP0v8txzz8EJJ5wAI0aMUP/ADz74YGh3Dmc+7LjjjtCzZ0/l/PPuu3o5e926dXDqqaeqHTRsfsWAtGWLvli88cYb8MlPfhKampqURvuqq67K9T0KRYAnIVi9wcXs1ucXa8lKvtCiiM2dtBv0/uqt6r+xNz/aqHZl+AC8Nz/aFGrMtUEJCCYnSYa5ohSMggAtvLnI6vjuHDoCbbIlR15Q3G2HPjCif5OqztGOJy245E40KKEhAy68Q73dzUG9G7VkhxZuP+D3qLcmIxSASGOOwWMHb8cve77oBZTkC1xWx19jW4ApUMbbpQa6bts5y9nKOzBkqM4AVEpuvPFGJWs7/PDDVXyir3vvvdc/5tprr4XPfvazavjrYYcdpqRyf//73/3n6+rqlCQPv2PS9PWvfx1OP/10uOKKK7roXQlRG3c4a4jWBlwnqCcViVr78TnX81Q5ojV2jCfjwjhIiRgxZcxAa6KAx9ogWXXSytEKr8ozvH9Pf7OMu5vmomowR2Z87Mvqsvf0qT13UN/nfbQxZKTQ3JaJldWZPUfD+jXBtAnDsiY9eRgyIJNHDVB/8+SVI08RkdF7g6L6ipJYeVM/bLZy5H5dWRsygPe9SkOT/b+2CHBgHs6I+Na3vqUNxyMwibnuuuvUcDyULfz4xz9WVqc4GwITHQQToxUrVviD+HB37uyzz1Y7egi6+eAOHSZWN910k5Ix4PUwkcLjhK5nKdudw12nO1/6UPX+7DSgJzz/wyMKIhPi8w0wWcBK0LurN6vrfffO2fDZfXZUpX0TlKRhIHRVjijw4GKI5+LDU21QQoDnpaF/ucjqtrAAhIsx7cTplaM238Rg0qgBsHzjSn9xRS01ShhpEY+SLvQ2eo6+OGWUOv5Tu2cDm8qNOnhy5O43ovfOdyX7NdVr14gKQNnXG8lRzBRydY9xbnV10btz4SGw5bfKV3vTaylJshGCMQpnFuGXizFjxsCjjz5a4LsTilE5MsEP9PuMHKDWoeOv+zfsNaI/XPfVfUP/nZxx2yuwcVsr/O2cT4Sq4rTJ1dtb/3Yeko0Jzy5c7X/YJfYY1let2xu2bfQTKjQ/sPUdZVhMsPV12qCxDriRNrgP9Rxl7bfTxGA+ZsLElNXtNaIfDOnTw0+isGKF75sndNyEx4RijC0hCAwZkhkFmX+rHxy1e0h+Z8ruOHwUhj9mAuctRcSmRENgbZUjiwU4GXuU58ZdTVVLvlP/i+DQu5/97Gfw+c9/PvQc/h/yt7/9rZIZnHjiibDPPvvAn//8ZzVlnCpMb731lhrGd8stt8BBBx0Ehx56KPz+979XrkF4HHLXXXepxtg//elPamDfV77yFfj+97+vhvMJ5QH1vRD/89wiv6rBF/4Z73wMNz77fqIPJq5SPy6Ku3tyNhys95znjoeWqHStfUb29193iCdlQOkCL88TXLKQZIdujZe4oCZ6oLcLmFvlyN1kG/QcZY/p19SggjiHdigJ07I0yq2uZ486+NykEb6LkDmJPGrGEQ8wJLHA4GdWp6Kwyeq0OUeWBTiQ1SUwZIjQdZf17lxMAigIQrqYQT2ouFFHUPUGFQcIbjJh9eaReSvU7j4H1xOcSfT6so3WJMavHHlrLBkAvLEse+59Rw+AI8cNVdffb8xAJQsnjhg31GnVjeelMIlJki12cfD5VWTIMCCoHOEHbpujqAtcH7l5hC3+YfymeIybifuODqozg3v3gL5NQdxAWXaTRZodqhxZNqto/caE5+L/fV0pUeIqR3zY7uF77hCS39UlmHOE0EiSkKwu1HPEkxyIcatzGTIYx5ejIUON9x2qk4J+Wli8eLHScPMheqjjxiSID9HDCtD+++/vH4PH19bWwksvveQfg5IGnDlBYPUJm2PXrw9kVByZJdE1yRHJpXhfzAvvr/V//u8H5sGvHns7JHmLI+ue1uEvirsP7at+fm/VFpjnBSEC+4A+tUe2IoIcNX6YkldhiX+FZWo232lKkuR8zJIjGm6XVPaQdneO7g2DzaRRQcLHBw4S0YYMeuXIxJQvRM044lWXNX7lqEE7Nq5yFBgy2N3qavMcAmtOIa8UXXdcAigIQnI+8uIQJkOYmBBfOWC0lsDQuq+GansyZYLP7bNJs0mC1psqR56agNh7RH+49Yz9lYICJeGj2KbWcXtnHQ0x6cIYSskawhMaXJa5ssDGmq0tSiGBy+Swvo0qIaENqzSDYF1zCvt66zsqJ7DaRR/yMTZx6RpWrLj6IqrfiFeOouIS/i3ue3UZXP/M+77igm/GcX503Dj1d/7rWQer9RSrMFxeHdlzxKpKWj8se0lU5SjWypsZPUTJyKOqW10/oByqkoL+i9AQPNuQPD5Eb+jQ7O4JUV9fr6aU5zNoT2ZJlJalXhCi5kzOC++u8RMcnJmALF4bDjLo7HPEb56FJZ7BAAc/0NJijIsp9fq8vXKT+uKl6P13HqR264gJO/bzE4nbnl8M/3X/69qwOh6EksgXKHHBHpsBeVSO+BRygswP8HzYLExVLazMTNypv/+hGY/jPT5xlSNqenWV7GnBR2tunri5AhCXCWTvr14zboiTrPmyOl+6YNilWucc6d9d98RtWHVZXfY7NWHbgnFXQ3crlSNBKJykDgeijhve19/A+/IBo3yDG1wPuCya98/yD8nIB7bKkbFWmptWE0b0Ux8s6cMlVZZGDeoJkzw1ACZHx/3u33DyDTN9qbI5xiEuNlG/0dC+Tb70zzdlSNF3xOXenLE7BCM0SFKH6zau+1py1LtRyayJqAGwyL6jsn1Yh+4WbGj65/KkgQRWxkhx4dq4++qBo2HuZZ+Gqd5nEfy7o1IiSXKE8YJiF0m+Vc9RRJUnjSEDxiaSzmlrvPG6HmXdc1QD1Uj5/YvkiMySKB1YXqcF/fA9g0SXLLfRNY76eahcb9OBP/z6chUknnxrlfUaRO8e9bDrDn3UQoSJDe6WobztJ5+boL6fst9ImDxqoFoEcZHBStIuQ7LJ1C3PL4b/nb0MHp0XTCXnVZ8NKZIj1FmTLA0DKC2muUwhJzBg0uKM1uIUhLAyg7tx2GtFQc/sjSKJX5RdqispwCoY8v2/vqYkJnHShQN2HqQFAgyAeuUoeimhe2h2SBfsPUfRbjn+AD+WSNt258hdrxytvKXnSCgWWD1AeVicPKs7QQqGkQN6qTWLNvAwNuEHcjJl0GYSGZtzfCDqB2sjKkfe+odrIV+Lx3uzj4hDdhusro2y5hEDeqq1EO+D4iMlZ+YcoTh1ArnKDe+f7eXWkqMUYyoo+TDXoLFeLxXK6ihxw6oRfljGjTtaT83YFFc5wh6tOZd+Gn4wbffQc2hJ/rdzpsJvvzzZV21QMuqKTdl712++d4p+WEpMyExCGUOwdbkmhyGwPfiYCYuszoxF5Sirq5XKUeGgIXi2IXl8iB6fEYG0t7crB7t8Bu3JLInSEczZaVDuMMR/HLGbWjwxgUG5AB9GZ9pR8yD03mrd4Uez7+xRpxYr3AniGnLsxzn1oDHw2mVHq10sXKBvPn1/+J/Tp6iFeldv14tY5VWwzB25JPI4LqtDqQEtcvRaHIZnVqdskEyQpIgIyvQoUcHrBIYM2cWd+o7w/fHdOfXaCFkdHou3qWy8LcnRL06eqK6Lc0DO/vOrWn+XjV126KOCe3B+vefItFM1IX15IF0wgowtOfKtRBMM8Ot0TyEnGsrZrU6yI6HA/PSh+XD6n16GGV6PZjXFJqwc4TgE/KB99Zcmq/9/0Yw63Azi677ZP6vJ6iymPrYqOxn14P+fca4bB62+MRm46JhxKnbQJqLLjIcwf8cNoCfmr/TvneYRoY03YTrWfe+vr8GRVz+rbTaa0HMUh8zkCOMW3SP1FqGEb6+d+vubhjw2kfQ8Ctt6T0wZM8ivAqGkj9QULlWDDeo7wr933NpKIx5sZkFWRYMm3YZ4QwZ/flLw/J5eVdO/B4lNZUdB/0XQnQ6TFz5ED3t/sJeID9HDCeQ4Q4LAgXyZTEb1JtExaBmOTnYEOtvtueeeMHCgbtMolB7a6UItNcrdsMyOi8G08cPg4F2yi9rz763RSvtmAOIys3dXhZtTbR/Wd2fzC7gBA292pUrWCZNGKFkF7nAhfFgdN2RIIo8jVx6UteFCQbIBeu3PH12gqlP3vBJdraSEj+/0YRJEcjmVHLHKEbLfmGxyhIMGedMrJmlRMjFMEH/9hUnwmy9Nsi68uKv6j/MO8XX1ZAjhcqtDvn9UsNOH96olRwnd6tIYMsQtzjYrb32X0NydK78AVO26bqF40IaUTbbc7StHA3v6H7SpmkLDWrFCz3ty8q0cIZTw4CYSl3TZkgHcZMI1n16zenOztXJkzjrC3t2z/zIbTr/1JSUNpMoRVlu4OQKC7w8laQ+9vlwleGafru39DurVQ1vHVZXLW2M/8P5GfRuDqtAXp4xUsXDqrkO02BRXOUoC/Zvhuk59ZFGVI5PeXuUormqE0HukzyNc8m0fTs5ldTE9R1zyzY6dussQ6/HlRE2VqxpS/4vgPKK5c+eqLzJhwJ9xijj+Mc8//3zlZvePf/xDWXDjDAiciXTSSSep48ePHw/HHnssnHXWWfDyyy/DCy+8oKaWoyMdHod87WtfU2YMOP9o/vz5ag7F7373OzWcT+h6KNFBFx4MEHd++yDVDIkL2gE7Z5PXBSs2wbqtQUJCC5zNEhXdZkw3O1spfXe2I0dJjwscQPrY+YcpPTJCO18YVKh8nrhy5MvqGrUZDjgNHBOelxevi/0QgqV1CkI414HA3qIdvPOieQQlhWSFevK+I+F7R+4GF356T126EDHjiDhlykit2mOCwY96kxZ7O6S9HW51CEobUSKC4FwKbvqQ1JBhtWeQge9PN2SIkJzFnLPFmG4evN44vgytvMWtTigWtBmTi3lMWnD9bo9wPCsVyzZQ5UivziCDvXUWjQy4nNrsOeIzf1BxYMqhSQHAN4eoyoL9rnGcd+Tu8PL/O0olFTw2hXuOguu+8sE6uPnfWUdYdNH72cNvwYqNnlMd22wbyAbBzlgYVAxpNp6NYCOyDvqwJAc36LAqxIfW8iTo6wePUb0+qNzgsYmk5/mAyQIlSJtjVA02KEFNIqX2Jd/e5wLcvKTYZN+0c8cY85y6WVBw8Ce8OOofX5bJEVR1bEo95+jVV1+FI444wv+dEpYzzjgDbr/9drj44ovVLCScR4QVIrTqRutumnFEVt2YEB111FHKpQ4H7uFsJAINFZ544gk1dXzKlCkwZMgQNVhWZhyVWXLkNZry5kzaxfp4Uwus47K6DdvVIsF3YminBoM3JiDYWOo/Z5m7Q/03CM4ASgJVZQI3OFPXbddm487bTc+9D8dP3JH1HDVqiz8G2BfeW+P3tPDZTybbWH+Slhw1NfgLIyUoPAjhIv+fR++pfiYjCtrlKwRD+zWpvi+yrI0LQLd940B49YN1cMDYQXDbC4tTW3lTZWxY3ybrTCJ7VSWucuSySzUqR+UYgLzUrzrDj1BMqBJRiuToB/fMhVmL1sK/LvxUbEN+scD48sGabVaTBN7sj5UjrhjA5IjPBTLd27B6hPOQzB4dvnGHbniY5Jw+dedE94rX4ooBxLTfpn83vJ+L7n9dOdjtN3oAvLZ0gzIzoqUON7kIkp6/uGitFo+iZj/xShi+J/rboKoB48Pyjc3+cFuz75X+ZiQDTyqrSwJuGlJvc/rKUSCri8NUYGBFj+zBo+bvRQ3vpn5Yl+SbjDnM48uJGlJuQHWSOjnC6eJRM2vw/yw4LTxqYjg609HAVxc4I+nf//532tsTSgAtlLsYfT38g/+qzc1a5Qh3UDDJwMUWwf+GuHwBLbp5cuTvZrHqxF479fMlEzzBiIJ2voIApH9QsH1wwGt/47aX1Q7dqx+s919LwYx03Ru3tcHcZRv810UmR6zplSpFCH6QIBnC/OVZ6QPKFG0f5Hlgoh3CfBnat1ElRiQtiZLVUSD5hDdHqmcOlSOC/v3wdZjY2F5PfwKX14NtCGxUNaock6Nq13ULxYM2n3Jx1kzLMwtXq2Ts7RWb4CBPWh0Frp0/+cebqrr9SW8wdSEkdbh241pDlRzOkN4kq2vRenBoNhJVKnhcQjDh4slRUDkK1j+sNvz88xNTr73Iakdsot//9MJiJWvDCtHt3zoQ7nl5Cfzyn2+r4eC4bPD+lc9NHgG/fOxtFbv4gHSbciN4/8FQW56A4MYdqgXmLt2gvszKESeNIUNSMN5iTyyRrueoPnnliMUF7J3CXt4oo5yaJJUjbcxE9jEe4/C/UawyosLGfK5cqI3ZnOzupE6OhOoGd+do0bVJ20jXjRbe2EzJweSBkiNu1Y3gTg196EZs7mkYoG44dT/fGjVd5Sg7NdxscjU/OODMi/+873UVXJDXl27wrTh3MGR167fp0gVskEVpiTlR3Uz2eIDB5Ih6kCgA8V04Dn9doSpHlKSQq2Aa6QK3C+fzImyYsgH674SSI9sCHLc4x1l5m7t6DWUtXejqOxG6E2poZ4kqR9jITlWqJO6fCDqUPjh3uVIMFCo5WrAiu2ajW6nt/+t+5cib28P5cO3WIDkyXEjNvqOg0pL8w7qNUOXIUzXgWoDLGf67KQXDs++rx3947DiVsJx92K5KLo6ue2iMgAkMgeoGdG/968tL/LgVJ6ujjTs0MTCTIxq+Tv++7uSIV44KlxxxcolNcS6q5sYdOullX1eTrHKUJDZZJN8ItiBQclSOm2M1oR+qi/L7tCCUNR+u26Y+6KNTGDdIIKj6g433pgkDd6wzg9O7hmOdyz3tMxN3VP1ESSEpHH74x+Djki4gKBPDuUsoD8FdKtwBowCDH+4paSFZ3SsfrFdBB/8WWBbHD+grjaGzmEw+u3C1HwAxoPJAgr03tPNHw0rJjMGkN9upjHKqSwMlKblIF9L0HJmyAb9yRNpuy+uDhtBoWR3+G7VbKkfmNctRuiBW3kIxwLWE/j+RZJZbPnDpE/ZhJntNiy9xywXsHUWH0L/NXuY/hq6hUX0/1HPEZXXkssb7jrYbc39Ichx2q6svaHJEPUckTcd/t+ufeU/13KA9OO8fxUoNzvezxcIzDx0bktnZ3GIxgVbD1tlGpNZz1LM+FOOTVI4K0XNkJkdYAeIur3HQv03ayhFtvNLL4nqOXOs2xSa+CWxu8h05Xp/lWW7UVnnlSJIjIRKcD/SXWR/4Usp53kRvXKxtFRLskaEF9K0Vm7WFhi/QZpOr6VhHASjNbpEN3Fmj+8FdSkqGmhqy906/L/p4C1zx8AK1mB248yC47ztT4Qg2wwnlefQhnTTVmPQg6NBHQWjpOj0I/fG5RfCN216BXzz6lv9++HvCyhFOWOcLP5kxmGACQcnLoASGDEngUsa0AZ/vnMYlHqasjgKfv0NnWYDplHFNr5oNKzv42L13rIDKUXUHIKE48PW12JUj7gSK8rQk0HGmuiApz7y9WjmEXvy3N1R1H6FdeGdy5FWGsnGgVRuVwM10trdmN6mod4onRxgHKRlMI/OyQUoEvB88L1VndvKc9lBuh71FyI+OGxdpf81BB9nj9h6uJUrobMeVGghK88Zf9pivksC1n2+O4c+7D9Utp82eo+Dx4vQcEfi3TlNdoX+bJHI1HhcwFmuJQcSICX5c3NB0W6J22O5DVDXwd1/JznQqN2qqXNVQfp8WKgxcVL9528uqAbIcmfneGpizZH1Or8VG0B/c8xr8+P/mw59e+EA9hvOLkL29/h8bVBUgOcIensscrySZlSOcPWHTy/fJU7qgBSE2Rwid9kj7jvxxxiLV8HrEnjvAvd85WO3IHbxLdoggMoTtYpGmmnZmv3LAKN+cgvcdYcC795Ul6mcKQL1Duu7s3CSSL9BjLigIFaznyKgcpZGK8A8H8ZWjYKnBDx2YtCL0smi3uuimV+40xO/jmL2GaWYh5ZkcZb9LciQUEt5Ts8FhOlOc5CjZtahyg7KxqB5mF1Qlwg/8/3n/62pzhDbjzCGspqwOP7CSiQ6NhFjMpHPb2tq1JAs3zoj/m7tcVZlwc82cVZMW2iDC+8mqGto0G/LXlmxQm3Uo98MP0mm45kuT4cFzD4HTp45RH8rx/ZJlOP3dUHqH6+aMdz72Yy3FF5Sl4eYnJmq0kRhVOdLmHBWhcpRG0YDQBmTc/D1zk42MPDDBxFEgn/GSTLchQ7LRFep1RozEZO+cw3eFEyfvBOVITZWrGsrv00KF8fC85fDMwo/hL7OyOzzFBAMAOoWZO0AucMfwjNtehjP+9HLi13BwJ46CCFY+Xlq01k+Ooqy0SapFMY8CEM7TwUoUStEo+clWZLI7iHyIKmrAbbrjXKDEBoM4BSAqn6NkAZO2v7+2zLdZpUXhoLFBYzEfkMcXf3S2OXqv4b517DKWAKKrEM2HIEy7VJIg7DmsX2zlSEuOCtxzlK+srj6u54gFIC7lo+qj7fVTdh6oErDxO/aNlUPw+UkE/jtectw4//fybHr1fii/WxO6SXJU/MoRk9Uxh9IoSH6HG0ymg6gJVmr+PmeZXx1GFniJEG2sXf7QAr+vZvyIfs71im/o4JpEmycPv74C3vDMdcitbi/vPFjlwntA2dvPPQXA947cPTQ0NS24QURJxcdbmv3K0UhPhUBrGsbatD0pqODAAe24vlJPKzdlwPdqSszx79PbW9OpQoRrJu9pclWOuBS8UG6FPPanVZCkqRxpPUde5Qj/bXAUyOUn7h1j5W0/PylB+H+z5Rh/oqit8o07SY7yhIbJ8V2ZYnHdU+/CF26aBX+bE+iso8BSOiY3uOiuZc5xSaFECP+/gcnVuXe/5g+Ti+r7QZtmzkRPuoDzgP7jrjnwo7+94c84wgAzwtNYk3wBdxLnLMkGqsmj8h/6qw1Z9QIxVXqQa//1jvo7YaWIVxrGDO7lf5A3HeaIb39yF7XojRrkyepYAHpgzkehe+mNhgxG0yuCu1TmYzaO2Ws4DO/XpN1nIZOjVLI6nhzFyepYIsOvibMyDt9zB9jV4nx4yXHjYe5lR6vBijbwAwNVj+gDjbmQoy7/O4ftov5etsHBXQ1Vxao1AAnFgcwYEKwO8A9p5VA54sfxYeE2rn3yHbjwvtfhrpeyVXjkLU9C921PNoZVEATX4aj1k6pHZBxw5Lih8OkJw1RP6jl3zlHx3B+K2qeHL5fGBOzm5xapGIJOeN/+ZNDXU4jYtJqpGswZTXEz/eKg98BNGZ5/d03oON5zxE2BeN+Rq3KEcfyTuw+BY/canrfcsJDJUZo5RxTz49B6jmqTV45s0vFypqbKd+wkOcoTkgeQHWcxedOTEpgSNBdrNgdBB93j0kL9RRiA8MM7BkGstOAHXZLK2SBHOmJfYybRclY5wkVs5yG9tOQIe5MwCOHCVogPtJTY4P3TLipWXqhKgruG2fe5S+jD91TPlpZXOyh4YUD4wpSR2mM0TwKlEg+/sTwUUNQsCcOtDuESDVcAQnDm0axLjkxsZZ7UTjaXyhGfBB8XhLikjfc5XfjpPeD2bx5o7V+z9SqFnvcbX8OVI+KSz4yHv53zCV/KV5ZW3l19I0K3gtZXopimDDzOJLUN58fxkQ82KC6gRDz72lb/g/73jtodjhoX9IaOHx49hHWwZ+dNCgBc43/zxUnqQzGe855XlvobLb0a6pS8imLuv73rn3vEbtBYX9gEAOOdXznyZHVEGgMiG0FsCpIjei8c7lbHE0w+fN0l+UbJ2F/OPAhuOm1KwZzXeGUurTMgbfIlcqvzYgjKB814aAM3AnFTDmONy6WVNu34wPkEt1JW1EjlSMgHaiwlx5liQh+8kzr88B29ld407VwqRwfsPAhu+voU/0P7uB37RvZv8EQC/3+FiRXKm7520Gj1GCYofPAclbKpR4l6pFDWUIgPtFrlyJPV4c4YJSa4a4hl8EMtum4MvqcdPAa+fGD23hEMmLeesT/cc/ZB/v2NGhgYMuA1zv7Lq+q/DVxsv7z/KG2RJxtunGdEO1xa5ShGllBI208a/McDZPLXsuSoLjdZXb40eOelDzRl2FaU0JChq+9E6E7Q7JpSSOu4KiFtz1GSeLbKcwB99cP1yv2TeoswicA1/Ccn7OWvLxMckjpz7h03DsBz4LBvuhbFJvyATckRDuCmPqdCVe35RhGOgaAqQ6hylOcGIRk8UHKEZh2veTGWqkpI7x71fmWNV9job4D0aSzdgF+s7NGmG95bGkh2zsdNxCVHYwb1ThRb8bPPr07ZB6afPFHbIIzb1Ku4ylFNdfccyZyjPCHXGyzFo847beNgUlBqRprhpBI5nhzhUNY0oAyDpkTj4oz2or//6r5K3oBzFKLglQEMPPjB+Tuf2lXtzN390hIVqCl4Y3JAA/touvmcD7ML976jCxOEKCDi34NMFGj4Ku1AHjh2kDURQ731lSeFdcdHGTacJNPDv/NJ178Aiz7eqnaifvH5iVppvXeP7NTxK07cSzXa0gKECdzAXg0qoYqShRQDNGXY8nF46G4cmNxh8zNa30aZSCA8mS5U1YufN+g5qqzsqNp354Tiy+qKnRzl5lbXmjihovEI+B7e+3hLyJUOm+h/esJecMu/F8EJzO46rnLELaepjzS7cZddS/CDL/XbPPbmSmWOgOsc9pkWCtq446YP2COEywH27GKMGOH1DOUKVaJoc/XJBauUjBwliMdPHAE3zXjf3yjDOPj9I7fCcV6ymFRWVwywGoXVI/z3T/u5CiXyF0zbAw7dPX4gMSUyZMaQhJNjPgOZc/0Q6TmqLCQ5yhMeDLAyUazkCM9Nc3CSVo7QIpRYlUBWhwkYfVjHAIR9RphYYI8LcvieQ2H2pdNid1d4ZYAG6yFUqcGFmcwXevcIKkckn6B+o/0KtEPnV462tPgfnjEB4b1Dh+U5iBBtYjFZwA/pmBjh3+zm0/dXiSW3gqXJ3adP3Vl7Pf5NsYEWzT1GDChc8pAErG7hPeP9p1nA8Z4fOu8QNbCwqypHFITIb6TSduf8wFNZty2UOeaohGIkR2hQgPFOl9Vl3eeiYgRuvFEsi7PzxioOyc2QVz5YF8wzYlUiVCWQMiEKXhHBzSiCYgH+nWijBddD2sgh2Txafxeycu8nR16MwM1CXCuxLxUNE3IxYzAhg4e5SzbAMdc+BwtXZStvOHx3fxZj8dqYIF149J7a69G8CGME/pvxv18pwL8PJkdpFA0IxqMfTNs90bGU8HHjiXwx1R/4T1iOg16jqKny0CTJUZ5wecDqTc1+FaTQ8EZ/7uoWBU+i8N6iwJ2rk2+cCV87cDRcfOw4ZtmtL85J/g/OKwMkIfPtQWtrVPVmxYbs/eCiR1OpUVaHwZB2BgslXyDtMgZxKoPj4sVd5w7bI7/kCP8uKANE6QdKNH520t6+3faYQb1UsMN+rShr8l+cPFHZtxZqYnxS6N8rl4nvcUkR0YMZNpg9aflgyhcqrHDkB55q3Z0T8gM3sHDNNF3EcK3hJO0FQtC985K/z1Ny6rMOG2s1acFKyjl3zYb//sx4rXKEazsqKFyuZrZK0bqIzT5zU+/VD9bDwpXRlt1R0CBYc5A2JUeY3FHlCJMFLilDCm3qQv2w73uVI1INYFWLkqN8GePFV/xvAhMj7IeZNn6Y6p3CBJBwbeziGv/w9w9V/60VqtcqbfKY77zDKE7z7M7RHKhQoAoFP1/Q/+8qbdNOH1BeefdeCCQ5ygPcIeMTwXmlptBQSRxZ482GiPuPVpPVxSRHWLHA/yPf8Oz7qkI01xusl8vizF1meOUI7xeDEO4ULt+YTfZ696hXO1NYsMCg9NRbq9UijNWFfOUE5v3g34N2iXjPEV5rDzZnKFewGRVnYKABBf+3QXkAJpmzFq2N/NCA0sUdJ+rNuKVNjoq3HBRLVmfKFyotCNHsiwpTXAhlwpl3vKIShr+ceaAmQ86ncoTjFp5/b436uvvlD+F/v/sJzd0T+eNz7yvZ10OvLw+5zWEcwQ9W2Mdp2zxZb9h9R7nVmb2yzyxc7UsGXcNek/YcceVAf6//CP9O1ESPG2kYv0jujEwyzIUKNWeOPkRTfMKkCftXC3E97Cu66gv7qDETmFDi0HI+J++rB45Sccv8N9bu03CgLRWkoqABvsUA465ZLSsEqB7xk6MKXOBrqrwfVpKjPNja2uH3sOTqCJcU7jSDTmh47TgJn54cxTkCBZrn73hmArlWb/iuCU+OED858np9cFcSd/+xaRSDwa3PL1aPHzh2cMF2LEhnjv9W9L7wPqiihJK6QlwLz+eafXHh0XvAfa8shaMn6L1K5QA59PRO2fSaa4WH26LnizlTo9KCUCBdqKz7Frqe9o4MvPDeGiVTPveuOfDw9z/pr7f59Bzx2WwYN9AmG9UExLurNqsKN/LGRxtVkoT/HePah/LvVz9cBz/82zzVm4pN6yZ8QxHBGUIuaFMPKzaoZqAPm1jpN13dkmC61YVlde2Q8Qb0UcUMq0evfJDtg53kjaUoFDsaG4CUHP34sxNg5vtrldV4IfgSMwUymX7yPlCufPdTu8IOfZrgC1Pc91+uoELiba/KWWlxiZtZpBnv0Z2oMBFKec44KnXliKR11z/zHvzuX+86J4xrVt4xhgy8L4YSiG8dMhY+laPcjGYd8R0qrsVFdx4u5aK+I6pYHT8xPJk6nw/m5tRulC+cetAYNaH6/E/vAcUGJSq//uIkTdZRLpBjUaEmm0dVjvDDW5w9dxpGevOliEoLQv6cI1mJhZTgbj8N6V6+sRku/t/X/ee2kBuo9wEnTXJEA7hJNWCOjrjv1aX+zxR60B2MNob+MXe52sB75I3lyl3OZINxL0mSo12G9FYVDwTnlqFbaC4bWvqcI1ZF8tY+tDwP3OqyfzuS1uEmEg1ULRTY5/KDo3b310SKD1gFRNlbpa1nhQad+7B3yNxkrQSGs97aSlM0IP/vM+PhR8eNg4N2GQTVSHWmhAXCDDilqhwh767aAr9+fKH6+XOTR4R6nTBh4q52OMW8rSPjtOAmpzhcqJ9duBrO+MTOsY4scXIB1Deb5XD6AE5NryTlwvv/tzeYDitiKO0rJGiAcMMz76nqEQY9aj79IdsRrVaOHD8Uzj1iV6VDLxY0+LbQZhOjDNvbSvsw4c85qsDgKXQtlLSgbBgrNv96a7UyO8DKPcnqsCL/zqotKZOjbCzAqgXOukOHOAKTnr97w62x2kLnRbkaGRxQlQV7Zhav3RpqdKeeI0ymUN0QlRyRU92w/k3w889PVH20aVzFIpMj7lbHxjqAZy5K/anU21RIC28C/39/waf3gC8dMAr+99VlcFwBNwWFroXLx0k+XUnsvVP/vGdsVTKSHOWB2ViatnKEO1T4Yc7W5Ii7d+iQg/0rqNum5Aj/P4abca98uM4/dtb7a0PJEQYt2lXEa2AfDwbQEWyuAYEBlSytMSnCxTpfTthnhHJAM2cHmTIo2p2jyhGCE8sLPbATh43ivCLU06OFqXwYDcD//i46prhJ4gFjB8H3jtwNDtktPEsqH0ydfKUZG1S7I5CQO5S0fGLXwfDE/FVqwwl7dNDghmR1WBVOkxzhMGXqBz1q/FD43VPvwpK12/yNNRxsjbJoTMi+esAouO7p9/xEh5INNGQg0CHNTI5IGrfLDr1jkyPacEQlAm5m5dsXSfNvzOSoFzML4o8hXz5glEoKub11ocF/p6TuakLlJUeVtmknSHKUiI3b2uDW5xfB/72+HFraMvCP7x2iGhRpkaeZBHGOcOY5P33tDJWYnHP4bvDNQ3b2EwI8z2d//7yyMMXKy3lH7ubPONpjWF+lY6VZQAg2+ps2ptRvhBpmlJBh8oO7cLbkiIavYuLC7U3zAXfC8MvETI56e3pWntydMKk4QQgDOiZ/QunBD1b/WYSmVxq+W6lBiJK5SkvqhK7n/dXZdXu3HfrAvP4blR00rvEqOfISFFrvkyZHuAmHsQwTg71H9Fff0SgHN+vGDukDf3gmmwxhvNprRLCrjHIw2wyc15auh1OmjLT2HGHS9PLider8VPFyVY4KJWfDdQgHbqMjH99Y4WZBRJO3aYmbR9/+5C4Fub5QPdAIFETW98pDlO4JuPrJhWqHDOUGuFhjpYYv8ui2hmBlJikvLl6rKkMoPfjVY2/DFQ8v8J/72SNv+bMdcLG+/KEFqtyPH/xotsMby7JW2wjej9l3hDI6an4nRxxX8rb442yQxaBa7IpKqHLk9RyN27GvshjFHchDdyutlbVQuZgSm0pLjqhPo9TzQ4TuUznadWgfP3kgd7ctTFZnM0FwgVUiZMzg3koKRFUflPA9Mm+FUgNgxQVlypOZOQGX1XGoh5RDPa1Ywcc1H3FVj+j9FHI22t/O+QTMuPiI0LBtHpvQ4roSpVBCuVaOuvRWhByQf7IEzPaqNLT4kyabKke7D+3rW5Ki/CDNOcd4H+6efmu1+j7zvTXwj9eXK/ncg+ceAl/af6TmbEP/h+ND9LBKZDbNUuUIP3yROYLLsQ514dT0WmxclSO007zn7Klw33cOLmjDvtC9wf+2uZ13pSVHKNm55fT94ezDZGdaSA5uhr3vrfloGEC71Cu8ZMLvOfIrR7p7nQtSEeBsNjo39bj+4el31c9nHjJW9YWiiQFK4yjOcMkaWWa/vWIzbPfmBhGUqOHx9BpbcoTvkYyECmn/j9I8m6somTJwSZ0g5Mqw/sF/Yw7PLKGMkU+hMWC5n4bOkeaYAgjtgO26Q2/1oQz/D8AHr0bx6gfZnqEzDx2rZHlYkcLK02+fygYgHEg2edQAuOyEvfwAh9alpsEBJRIoreOs8apYQ/r28Hfd+KwjXmmiylGxBthGJkds8Cg2vO5SwCnVQvcHd3dpd7wSXYFQSjRtwrCqtUsVcgM3urA6hHEH+zWpckRrvF858mIHurC5XE05tPE3ZoieHN3zylLVu4RJ0RmHBNLkozyraXS240NVcZA1ypixh+fN5YHKgcdNNEEgFzIuZyMwYaK+2VLM2eGxqdA9r0L1wW3jzf50ofyR5CgG7O/BBR6TkqmelahfOdqe/Q8eF3jaKUsircOE682PNvkzdqhiM/vDdfDakvV+0oRgMPrtVyarIPe5STuFdrw+s3fW3QbnXdhkdapy5AfO7L399B/zYcJlj8MrXoJGNt5dkRzJh0IhX/i8k0qrHAlCLrzvSeqwwoMbZDQvZ8XG7cpUgZIK2jhAWTY5hCax8R4zKBsLSFZHhj1fmDJSk6P96LjxMOuSI9XcIS6r23N4X2UmhOCQWlvlCJMpkpPiWAw0Dbrwvrnw7TteUWZFFK8w9pZCTcBjk1SOhHzhsYj+/yhUDpIcxTBvWVYzjZaGlDyYsjrUYNPOFsoAcIfurpc+hFv+vUgZL4TO+dFGFawwoUJZHdkl/uXFD9X/iVAiQX1MNCPnhR8dqUwXuN8/bpKfNnWM+vmJBavgRVY9Ilkd7l6QrG7Bik1qEOntMz9QgfKHf3tDBdKuTI56S3Ik5An//4r0CQjVAMmoqdJOsjPs0dnaEiRB2HOKLmxUscGNuZtmvK9c5/Bnkw/XZWPbzp7ce7ehekz4+sGjQx8AURKN8MrRnsP6+k6lf3zufW3OHsXNgb3RAKiHH69ue2GxsglHS/L/fuBNvwpWSEldFGTnjUhyJAjVjXwyjYGMD3BCNzV/40KOsgW+A4YSAmTB8k0q8cDFHbnmyXfgpyfspTm30U7a/mMGKQMEdAX6v7nL4YX3sskNDt1yGSPwxu0R/XvClDGDVF/Sfa8ugwvunasmkmO1Cc0eSFa335iBKkC+tWITXPy3N9TjGC+xufZ7d7/mSxrQkKHY8ADKZ0kIQq5w16lKk9UJQj7JEcneKEHBniOy8UZTARwDgX1BKIn72+xlKm79z3OL1PP9murhuq/u68+Uw8oNurghFOvQmIEsrlE5sZvXX2vDrByhbf89Ly9Vm3IX3vs6HLzLIDUUnIbAYmJE/9+97ql3oZn10T7w2kcw452PC27GEIVmyCBxSSgAfBaYUFlI5SgGrPKQphrlBNTzg/IDv3LUswGO8LTX1z39Llz6YDYxwsoQ2pRe9o83Nac4lM8h+++cHSq3105ZBzrioLFZ+Z4NLqvb2dOF/+SEvVTVBwPjN257Bb5w0yx4+u3V/vH43J3fPkhN+Kbenqu/NMmvONGgO0yqShmAsJFezBeEQg6CFVmdUA1QhYck2dRzhLP2SO5NM4HOOzI7PwcrRn96frH6GTfz0Cn1e399zZfSLVuP84w61bpMyRZaX2Oig5zuqRRcoG04xjzswUWZH67t13x5knKke/69NfCbJ95Rm4aYhFEs+PahY2Hf0QPUveAsoU/tsQP86Lhxfs8R2oN/+QC9WlUs+mmVI9k3FvKH2i2EykNWgAjQZeddb4duH8+2FGVwWGlBaR012eFu2NcPGg0vvLsGHpu/UiVNKCvAeUhfu/kl5UyH8yGuOHFvZW3673fXaBO3+bwIqhy54I5ANDgVg+D1X9sP/vvBedDcllFBjqzASZJw8C6D4Z8/+CQ8uWAVHLv3cBWYsII1f/kmOGnyCDjZmEVREl03M2MQhFyRniOh2lju9QBRTxFu2mESgskNyaRp7tBnJ+4INz+3yN/owyHbN5y6H3zlf15Usem7d86Be84+GK56bKF6fuLI/tr/j6750mRYuGqzihtRoInBM/91uEqoSPkwbng/+PlJE5XMfPTg3vDswtUqNqFsDY/Hr/u+MxV+//R78OZHG5XyATfx8AufO3Lc0JKZI3BVg1SOhEKAmxDve4ZXQmUhyVEEKAfAXS78D5xK+5iQzFmyQQUgKpdi5QiDwa+/uA8sWrMFPli7DX71hX3U8Lj/OnpP+OrNL8JfX16iXotJUou3Q4ZudJQwYNKFCRdWeqIstXE3jkq1vEcI5x898B+HqJ83N7ep663b2gb7eP1MNKjvKwcGu3A///xEKDVNDbVqZxJ7rnrL7pxQALhbnaRGQncHe1opOaIhr9hrh32vaJxAkjtyAsXnsBpz6i0vQWN9LVz22QkqgcENteOv+7eSWx/5m2fVph9K6C7/3F7a9bByRNWjOPoas4PMgeAo27vy4QV+ny2C93Lhp/fQXnPyfqXZrHNu3IlbnVAAbJbxQmUgn04jWOBZkO49op+/E4YabGTeso3gqQP8+QgYGHA2Eeq6yaBh6q6D4ZO7D1HVIhr0ihI93LnjfUXYd4TJ0UFj3f1GBCZrmBxR5cgE7+Psw3aFckRNIu/VoFz9pOlVKFQA+sYndlbmIljFFYTuDK79KNdGyKWOfubJEZdJY//PH0+bomQ+1OeDUrw7vnUgnHPXbFi6LptsnXvEblriUmjw2v9z+v5QjohbnVBo8P9PD7+xAj6/705dfStCSiQ5ioDKobsPC3bNaGjr656LHS6iWCHiWmVTr4xyul8//raSPGAA+/5Ru/t6cOIrB45S5yT3uSh+cNTu8OzCj+GTe2TdgCoNDEIqOSpBj5NQHfzU2O0WhO4K2WpjosMlZzSywZYcIcfsFZbFYSL0yPc/CVc99ja0tXfCeUfuBtUKus4SPUXVIBQA7OV+/SdHQ1/5rFNxyL9YBDaLa0qOaBI57wFyga+/4dQpkcfg0Lznf3hkovs6YdII9VWp0A5db9mdEwRBSMXyDc2apI7Y0esvfc+bgZTUYAeNhn52Uukl1uWGVI6EUowvESoDsQqLAPuHEN4DZErZsLlVyG2xEEcgQRCEdPj9Rp6jHEGOdZ2e3LuPZ8ggJEOSI0EQCFk9HWD/wrL12SA0docgIcKehv86eg9YvGabGoi37+is45yQQ+VI3OoEQRBSYZoxEGS/jeCwcOlzSAdKFNHwCC3FS+WQJwhCeSLJkYMla7epHTiUJuCUcQ7NjRByQypHgiAI+fUcjRgQmDEg2IN6zF7DYPehfeHsT+2i5HJCOtB5FgeoS+VIEKob+XQaY8aA08Xj3OOEdKBbHzJhx2T2sIIgCIKeHO1kVI4wGfrjaeXpBFdJG3eSHAmCIMlRCjMGoTCcMmUkHLbHDsqSXBAEQch9AKxQOHBYOsrpJ+xYPDtzQRDKH0mOHCzyHH92GdKnq2+lWyKJkSAIQjqwHwYrG7aeIyF/rjhxL/jv48dLz5EgVDniVhdXOWJmDIIgCILQVaza1Kx6YdE4YLAMPC44KKGXxEgQBEmOYpIjbuMtCIIgCOXQbyS9sIIgCMVBkiMLG7e1wdqtrepn6TkSBEEQysvGW3eqEwRBEAqHJEcRw1+H92uC3gmnjAuCIAhCVwyAFQRBEAqHfPK3MHpQL7j6i5OgrSPT1bciCIIgCIppE4bBgF49YOfBomgQBEEoFpIcWRjcp1HZTQuCIAhCuTBueD/1JQiCIBQPkdUJgiAIgiAIgiBIciQIgiAIgiAIgpBFkiNBEARBEARBEIRyT46uv/562HnnnaGpqQkOOuggePnll7v6lgRBEARBEARB6KaUbXJ07733woUXXgg/+clPYM6cOTBp0iQ45phjYPXq1V19a4IgCIIgCIIgdEPKNjm65ppr4KyzzoJvfvObMGHCBLjpppugV69e8Kc//amrb00QBEEQBEEQhG5IWSZHra2tMHv2bJg2bZr/WG1trfp91qxZXXpvgiAIQnUjkm9BEITuS1kmR2vWrIGOjg4YNmyY9jj+vnLlSutrWlpaYNOmTdqXIAiCIBQSkXwLgiB0b8oyOcqF6dOnQ//+/f2vUaNGdfUtCYIgCN0MkXwLgiB0b8oyORoyZAjU1dXBqlWrtMfx9+HDh1tfc8kll8DGjRv9r6VLl5bobgVBEIRqIBfJt6gaBEEQKouyTI569OgBU6ZMgaeeesp/LJPJqN+nTp1qfU1jYyP069dP+xIEQRCErpR8i6pBEAShsijL5AhBTffNN98Md9xxB7z11ltwzjnnwNatW5WUQRAEQRAqAVE1CIIgVBb1UKZ8+ctfho8//hguu+wytSM3efJkeOyxx0I7di46OzvVd5EwCIIglBZad2kd7i7kIvlGVQN+ERKbBEEQyjs21XR2t+jlsWzZMpEvCIIgdCFYJRk5ciR0J9C6+8ADD4Tf//73vuR79OjRcN5558GPfvSj2NdLbBIEQSjv2FS2laN8GTFihHrzffv2hZqampyySwxgeI5K6V+qtHuutPtF5J6LT6XdLyL3rIN7bps3b1brcHcDJd9nnHEG7L///ipJ+u1vf5tK8l1tsanS7heRey4+lXa/iNxz9cSmbpscoYNQIXYsK9HcodLuudLuF5F7Lj6Vdr+I3HMAmg90R/KVfFdrbKq0+0XknotPpd0vIvfc/WNTt02OBEEQBKEYoIQOvwRBEITuR9m61QmCIAiCIAiCIJQSSY4coLvQT37yE81lqNyptHuutPtF5J6LT6XdLyL3LJSKSvt3q7T7ReSei0+l3S8i91w999xt3eoEQRAEQRAEQRDSIJUjQRAEQRAEQRAESY4EQRAEQRAEQRCySHIkCIIgCIIgCIIgyZEgCIIgCIIgCEIWSY4sXH/99bDzzjtDU1MTHHTQQfDyyy9DuTB9+nQ44IAD1HT1oUOHwkknnQQLFy7Ujjn88MPV5HX+9d3vfrfL7vmnP/1p6H7GjRvnP9/c3AznnnsuDB48GPr06QOnnHIKrFq1qsvuF//tzfvFL7zHcvn7Pvfcc3DCCSeoKc94/QcffFB7Hn1WcEjljjvuCD179oRp06bBu+++qx2zbt06OPXUU9WQtQEDBsCZZ54JW7Zs6ZJ7bmtrgx/+8IcwceJE6N27tzrm9NNPh+XLl8f+2/zyl7/skntGvvGNb4Tu59hjj+2yv3Pc/dr+u8avX//61132NxaSI7GpeuMSIrGp9PdcjrGp0uJSJcYmSY4M7r33XrjwwguVjeCcOXNg0qRJcMwxx8Dq1auhHJgxY4ZaCF988UV48skn1f9xjz76aNi6dat23FlnnQUrVqzwv6666iroSvbaay/tfp5//nn/uQsuuAAeeughuP/++9X7w0Xn5JNP7rJ7feWVV7R7xb8z8sUvfrFs/r74743/beKHJRt4P9dddx3cdNNN8NJLL6lFHf87xoBP4MI4f/589f4efvhhtXidffbZXXLP27ZtU/9/+/GPf6y+//3vf1cfrD73uc+Fjr3iiiu0v/33vve9LrlnAoMOv5+//vWv2vOl/DvH3S+/T/z605/+pAIMfvDrqr+xkAyJTdUdlxCJTaW/53KMTZUWlyoyNqGVtxBw4IEHdp577rn+7x0dHZ0jRozonD59emc5snr1arRi75wxY4b/2Kc+9anOH/zgB53lwk9+8pPOSZMmWZ/bsGFDZ0NDQ+f999/vP/bWW2+p9zRr1qzOcgD/lrvuumtnJpMpy78v/q0eeOAB/3e8z+HDh3f++te/1v7OjY2NnX/961/V7wsWLFCve+WVV/xj/vnPf3bW1NR0fvTRRyW/Zxsvv/yyOu7DDz/0HxszZkzntdde29kV2O75jDPO6DzxxBOdr+nKv3OSvzHe+5FHHqk91pV/Y8GNxKbCUulxCZHYVPx7LvfYVGlxqVJik1SOGK2trTB79mxV5iVqa2vV77NmzYJyZOPGjer7oEGDtMfvuusuGDJkCOy9995wySWXqN2PrgTL5lhO3WWXXdSOxZIlS9Tj+PfGHUb+N0dpw+jRo8vib47/Tdx5553wrW99S+1ilOvfl7N48WJYuXKl9jft37+/kuHQ3xS/Yyl9//3394/B4/G/d9zNK5f/tvFvjvfJwTI6Sl323XdfVXJvb2+HruTZZ59VMqI999wTzjnnHFi7dq3/XDn/nVEi9Mgjjyg5hUm5/Y2rHYlNxaFS4xIisanrqITYVKlxqVxiU31RzlqhrFmzBjo6OmDYsGHa4/j722+/DeVGJpOB888/Hw455BC1EBJf+9rXYMyYMWrRf+ONN5ReFsvAWA7uCnDhu/3229X/SbEMevnll8MnP/lJePPNN9VC2aNHj9Aig39zfK6rQV3shg0blIa3XP++JvR3s/13TM/hd1w4OfX19eqDTDn83VFigX/Xr371q0oTTXz/+9+H/fbbT93nzJkzVfDH/6b+fzv3D9L2E8Zx/PtD1CpirShVGoRULXQR1EGydFFEKQhdtF0KhfoXt7YIgkuH4pTFITiICg6lizgKMRH8QwWlwU1I0BbBLh1UUOtyP55HUhJra4c237v2/YI0jTHl+nC5T+6buwuHw760U5YuyFKbYDDopVIpb3R01Ovs7NTwycvLs7rOs7Ozuj/k8lIh22oMsulPcDmXBNnkDxeyyeVcsiWbmBw5TNZ3y0CeuU5aZK4blU2EsvGxtbVV3yS1tbU5b6e8KdMaGho0lGQAf/funW7ItNnU1JS2X8LG1vr+beSKbXd3t27cjUQiWc/JnovMviQfYPr7+3UzeGFhYc7b+vjx46y+IG2SPiBX7aRP2EzWdMvVctncb3ON4R4XssnlXBJkU+65kk0u55It2cSyugzyVbTMqi+fSCOPq6qqPJsMDw/rJrp4PO4FAoGf/q4M+iKZTHo2kKtx9+7d0/ZIXWV5gFwBs63mHz9+9KLRqPf8+XOn6puu28/6sdxf3sgtX0/LCTZ+1j0dPlJ72SiaeWXuR7WXdu/t7Xk2kOU5Mo6k+4KtdV5ZWdErytf1bRtr/C8im/48V3JJkE2553I2uZJLNmUTk6MMMgttbm72lpaWspYHyONQKOTZQK5YSPjMz897sVhMvza9TiKR0Hu5imQDOS5SrmRJe6Te+fn5WTWXN4as/fa75tPT0/rV88OHD52qr/QJGeAya3p0dKRridM1lXsJfllbnyb9Sfp7OlD9Ch/ZByDBL+uKryO1l3XSl5cI+GV/f1/Xdqf7go11Tl91lveenB7kWo3/RWTTn+dKLgmyKbdczyZXcsmqbMrJsQ8Oefv2rZ6cMjMzoyd69PX1mbKyMvP582djg8HBQXPz5k2zvLxsDg4Ovt1OTk70+WQyaV6/fm02NzfN7u6uWVhYMHfv3jUPHjzwrc0vXrzQ9kp71tbWTFtbm6moqNDTjMTAwICpqakxsVhM2x0KhfTmJzkJSto0MjKS9XNb6nt8fGw+fPigN3kbh8Nh/Xv69Jzx8XHtt9K+7e1tPfklGAya09PTb/9GR0eHaWxsNBsbG2Z1ddXU19ebJ0+e+NLm8/Nz09XVZQKBgEkkEll9++vXr/r69fV1PalGnk+lUmZubs5UVlaap0+f+tJmee7ly5d6epX0hWg0apqamrSOZ2dnvtT5un4hDg8PTXFxsYlEIt+93o8a49eQTb+Xi7kkyKbcttnGbHItl1zMJiZHV5iYmNDBp6CgQI9Pff/+vbGFdKqrbtPT0/r8p0+fdDAsLy/XIK2rqzOvXr3STueXnp4eU11drfW8c+eOPpaBPE0GxaGhIXPr1i19Yzx69EgHHj8tLi5qXXd2drJ+bkt94/H4lf1AjvBMH5k6NjZmbt++re1sbW397v/y5csXHQxLSkpMaWmpefbsmQ5gfrRZBvEf9W15ndja2jItLS36AezGjRvm/v375s2bN1kDfi7bLB/62tvbdYCWY3/lmNHe3t7vPqzmss7X9QsxOTlpioqK9Ajdy/yoMX4d2fRv55Igm3LbZhuzybVccjGb/pM/fv/3UQAAAADgFvYcAQAAAACTIwAAAAC4wOQIAAAAAJgcAQAAAMAFJkcAAAAAwOQIAAAAAC4wOQIAAAAAJkcAAAAAcIHJEQAAAAAwOQIAAACAC0yOAAAAAIDJEQAAAAB46n9xcmM/DHwJLgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1000x1000 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 10))\n",
    "plt.subplot(2, 2, 1)\n",
    "plt.plot(logs[\"reward\"])\n",
    "plt.title(\"training rewards (average)\")\n",
    "plt.subplot(2, 2, 2)\n",
    "plt.plot(logs[\"step_count\"])\n",
    "plt.title(\"Max step count (training)\")\n",
    "plt.subplot(2, 2, 3)\n",
    "plt.plot(logs[\"eval reward (sum)\"])\n",
    "plt.title(\"Return (test)\")\n",
    "plt.subplot(2, 2, 4)\n",
    "plt.plot(logs[\"eval step_count\"])\n",
    "plt.title(\"Max step count (test)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "normalization constant shape: torch.Size([376])\n",
      "observation_spec: Composite(\n",
      "    observation: UnboundedContinuous(\n",
      "        shape=torch.Size([376]),\n",
      "        space=ContinuousBox(\n",
      "            low=Tensor(shape=torch.Size([376]), device=cuda:0, dtype=torch.float32, contiguous=True),\n",
      "            high=Tensor(shape=torch.Size([376]), device=cuda:0, dtype=torch.float32, contiguous=True)),\n",
      "        device=cuda:0,\n",
      "        dtype=torch.float32,\n",
      "        domain=continuous),\n",
      "    step_count: BoundedDiscrete(\n",
      "        shape=torch.Size([1]),\n",
      "        space=ContinuousBox(\n",
      "            low=Tensor(shape=torch.Size([1]), device=cuda:0, dtype=torch.int64, contiguous=True),\n",
      "            high=Tensor(shape=torch.Size([1]), device=cuda:0, dtype=torch.int64, contiguous=True)),\n",
      "        device=cuda:0,\n",
      "        dtype=torch.int64,\n",
      "        domain=discrete),\n",
      "    device=cuda:0,\n",
      "    shape=torch.Size([]))\n",
      "reward_spec: UnboundedContinuous(\n",
      "    shape=torch.Size([1]),\n",
      "    space=ContinuousBox(\n",
      "        low=Tensor(shape=torch.Size([1]), device=cuda:0, dtype=torch.float32, contiguous=True),\n",
      "        high=Tensor(shape=torch.Size([1]), device=cuda:0, dtype=torch.float32, contiguous=True)),\n",
      "    device=cuda:0,\n",
      "    dtype=torch.float32,\n",
      "    domain=continuous)\n",
      "input_spec: Composite(\n",
      "    full_state_spec: Composite(\n",
      "        step_count: BoundedDiscrete(\n",
      "            shape=torch.Size([1]),\n",
      "            space=ContinuousBox(\n",
      "                low=Tensor(shape=torch.Size([1]), device=cuda:0, dtype=torch.int64, contiguous=True),\n",
      "                high=Tensor(shape=torch.Size([1]), device=cuda:0, dtype=torch.int64, contiguous=True)),\n",
      "            device=cuda:0,\n",
      "            dtype=torch.int64,\n",
      "            domain=discrete),\n",
      "        device=cuda:0,\n",
      "        shape=torch.Size([])),\n",
      "    full_action_spec: Composite(\n",
      "        action: BoundedContinuous(\n",
      "            shape=torch.Size([17]),\n",
      "            space=ContinuousBox(\n",
      "                low=Tensor(shape=torch.Size([17]), device=cuda:0, dtype=torch.float32, contiguous=True),\n",
      "                high=Tensor(shape=torch.Size([17]), device=cuda:0, dtype=torch.float32, contiguous=True)),\n",
      "            device=cuda:0,\n",
      "            dtype=torch.float32,\n",
      "            domain=continuous),\n",
      "        device=cuda:0,\n",
      "        shape=torch.Size([])),\n",
      "    device=cuda:0,\n",
      "    shape=torch.Size([]))\n",
      "action_spec (as defined by input_spec): BoundedContinuous(\n",
      "    shape=torch.Size([17]),\n",
      "    space=ContinuousBox(\n",
      "        low=Tensor(shape=torch.Size([17]), device=cuda:0, dtype=torch.float32, contiguous=True),\n",
      "        high=Tensor(shape=torch.Size([17]), device=cuda:0, dtype=torch.float32, contiguous=True)),\n",
      "    device=cuda:0,\n",
      "    dtype=torch.float32,\n",
      "    domain=continuous)\n",
      "rollout of three steps: TensorDict(\n",
      "    fields={\n",
      "        action: Tensor(shape=torch.Size([3, 17]), device=cuda:0, dtype=torch.float32, is_shared=True),\n",
      "        done: Tensor(shape=torch.Size([3, 1]), device=cuda:0, dtype=torch.bool, is_shared=True),\n",
      "        next: TensorDict(\n",
      "            fields={\n",
      "                done: Tensor(shape=torch.Size([3, 1]), device=cuda:0, dtype=torch.bool, is_shared=True),\n",
      "                observation: Tensor(shape=torch.Size([3, 376]), device=cuda:0, dtype=torch.float32, is_shared=True),\n",
      "                pixels: Tensor(shape=torch.Size([3, 480, 480, 3]), device=cuda:0, dtype=torch.uint8, is_shared=True),\n",
      "                reward: Tensor(shape=torch.Size([3, 1]), device=cuda:0, dtype=torch.float32, is_shared=True),\n",
      "                step_count: Tensor(shape=torch.Size([3, 1]), device=cuda:0, dtype=torch.int64, is_shared=True),\n",
      "                terminated: Tensor(shape=torch.Size([3, 1]), device=cuda:0, dtype=torch.bool, is_shared=True),\n",
      "                truncated: Tensor(shape=torch.Size([3, 1]), device=cuda:0, dtype=torch.bool, is_shared=True)},\n",
      "            batch_size=torch.Size([3]),\n",
      "            device=cuda:0,\n",
      "            is_shared=True),\n",
      "        observation: Tensor(shape=torch.Size([3, 376]), device=cuda:0, dtype=torch.float32, is_shared=True),\n",
      "        pixels: Tensor(shape=torch.Size([3, 480, 480, 3]), device=cuda:0, dtype=torch.uint8, is_shared=True),\n",
      "        step_count: Tensor(shape=torch.Size([3, 1]), device=cuda:0, dtype=torch.int64, is_shared=True),\n",
      "        terminated: Tensor(shape=torch.Size([3, 1]), device=cuda:0, dtype=torch.bool, is_shared=True),\n",
      "        truncated: Tensor(shape=torch.Size([3, 1]), device=cuda:0, dtype=torch.bool, is_shared=True)},\n",
      "    batch_size=torch.Size([3]),\n",
      "    device=cuda:0,\n",
      "    is_shared=True)\n",
      "Shape of the rollout TensorDict: torch.Size([3])\n"
     ]
    }
   ],
   "source": [
    "base_env2 = GymEnv(\n",
    "    \"Humanoid-v4\",\n",
    "    from_pixels=True,\n",
    "    pixels_only=False,\n",
    "    device=device,\n",
    ")\n",
    "env2 = TransformedEnv(\n",
    "    base_env2,\n",
    "    Compose(\n",
    "        # normalize observations\n",
    "        # DynamicObsNorm(in_keys=[\"observation\"]),\n",
    "        ObservationNorm(\n",
    "            loc=np.load(\"norm_loc.npy\"),\n",
    "            scale=np.load(\"norm_scale.npy\"),\n",
    "            in_keys=[\"observation\"],\n",
    "        ),\n",
    "        DoubleToFloat(),\n",
    "        StepCounter(),\n",
    "    ),\n",
    ")\n",
    "print(\"normalization constant shape:\", env.transform[0].loc.shape)\n",
    "print(\"observation_spec:\", env.observation_spec)\n",
    "print(\"reward_spec:\", env.reward_spec)\n",
    "print(\"input_spec:\", env.input_spec)\n",
    "print(\"action_spec (as defined by input_spec):\", env.action_spec)\n",
    "rollout = env2.rollout(3)\n",
    "print(\"rollout of three steps:\", rollout)\n",
    "print(\"Shape of the rollout TensorDict:\", rollout.batch_size)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "collector2 = SyncDataCollector(\n",
    "    env2,\n",
    "    policy_module,\n",
    "    frames_per_batch=frames_per_batch,\n",
    "    total_frames=total_frames,\n",
    "    split_trajs=False,\n",
    "    device=device,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, tensordict_data in enumerate(collector2):\n",
    "    break\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(699, device='cuda:0')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.sum(tensordict_data[\"next\"][\"done\"])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "视频保存成功！\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "\n",
    "ims = tensordict_data[\"pixels\"].cpu().numpy().astype(\"uint8\")\n",
    "fourcc = cv2.VideoWriter_fourcc(*\"mp4v\")\n",
    "out = cv2.VideoWriter(\"output14.mp4\", fourcc, 30, (ims.shape[2], ims.shape[1]))\n",
    "for frame in ims:\n",
    "    out.write(frame[..., ::-1])\n",
    "out.release()\n",
    "print(\"视频保存成功！\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# save and load weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(\n",
    "    {\n",
    "        \"policy_weights\": policy_module.state_dict(),\n",
    "        \"value_weights\": value_module.state_dict(),\n",
    "    },\n",
    "    \"model_weights.pth\",\n",
    ")\n",
    "np.save(\"norm_loc\", env.transform[0].loc.cpu())\n",
    "np.save(\"norm_scale\", env.transform[0].scale.cpu())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
